There's other ways to implement this, certainly. But it's just pretty convenient to approach things this way, especially if I'm dealing with multiple repos. Like each implementation could be its repo and linked in, and as long as they all conform to the right signature, some client program/library could make use of them with first class modules.
Smells like H1B Visa
C++ is a bloated aging whore that shouldn't be used for anything anywhere by anyone ever.
Whenever you like. If you want to be safe wait until you get a role where that's your actual job title. A lot of smaller companies will basically let you have whatever job title you like it you ask nicely. Try not to bite off more than you can chew though. Senior devs are expected to be good at management and communication, not just programming.
Yep, it's not going to happen anytime soon. People are jumping on the "everything is going to be rewritten in memory safe languages" bandwagon but I'm guessing they don't remember the last 6 times that bandwagon failed to go anywhere and everyone got off it. We've had languages (e.g. Ada) that are significantly more safe than Rust and Go since the 80's. We've had languages (i.e. Java) that have been way more popular and still we haven't seen adoption for even basic tools. It's not that the problem is impossible, it's that there just isn't a good fit and most people far prefer to write new stuff than rewrite old stuff.
Yeah we've seen this a lot. Java had similar ideas. I hate to say it but it works. Nobody thinks of themselves as the idiot programmer but these languages often end up being very popular and I can't deny it's true that most programmers are googling idiots.
It means what it says really. If you have a 32bit processor and you try to compile the rust compiler it will fail.
It's due to memory limitations. Each byte of memory that's used by a process needs to have a unique address (i.e. number). 32bit machines can only handle 2^32 different numbers. That gives you about 4GB of usable memory per process. Not enough to compile rust sadly.
No, it can compile simple programs. It just won't compile the rust compiler itself. What this really means in practice is that every time you want to update your rust compiler on a 32 bit machine you need to do the compiling that's needed for that on a 64 bit machine and then transfer the result over.
Ah, thought you had a case where first-class modules were essential. What you're talking about here is just the text-book purpose of ordinary functors: you can write library code as a functor and let clients apply it to whatever base modules they have, possibly ones from third parties. In your case, you could replace your stream function with a functor of two protocol modules.
Most of your post sounds good, but Rust's memory safety is supposed to come from the type-checker, and that should be verifying type correctness before you move to a representation like SSA/CPS. But I'm sad if what you say is right and LLVM is a shit-show.
You can cross-out assembly outright imho. I'm doing MIPS assembly for a course and while it illustrates fundamental Computer Architecture concepts very well, it also illustrate why you wanna let your tools write it for you. Hand-written assembly lacks maintainability, performance, and portability by definition.
As much as I like to shit on Go, its compiler it really interesting and well engineered. They pretty much made the assembler architecture independent by writing their own meta-assembly.
www.youtube.com
The difference between functors and this situation though is that you can't pick the functors dynamically at runtime. I suppose you could manually generate all combinations of src and dst and create a stream function for each combination, and put them in an alist (or a hash table or whatever), but I find in some contexts the first class module approach is less messy.
Actually, several unikernel implementations exist that have indeed rewritten the OS in a memory safe language.
In your case, where you're not doing anything complicated with the types in your modules, you could just use records, or otherwise find an appropriate runtime type to represent a protocol. Modules are cool because of what they allow you to do at the type level, and if you need this at runtime, then you are talking about a program which synthesises new types at runtime, which isn't something that your example does. Synthesising new types at runtime isn't novel in typed functional programming (you'll get it if you use polymorphic recursion), but I want to see a case where we need this sort of thing and first-class modules are the answer.
Mirage OS looks stupidly cool, and the obvious way forward for modern internet architecture. I'll try to deploy my current home project with it.
It's been a good few minutes since this thread's last Lisp plug anyhow, so I thought I'd share that famous Guy Steele quote since we're on the topic of idiot target audiences (I kid! Nothing but love from me for the C++ guys.):
Guy Steele (Re: Java's quick and widespread adoption) said:
Aww, you don't like Ruby, @Citation Checking Project ? But don't you want to be in the company of such fine, upstanding individuals as this
## How to be lazy! By Yotsubaaa
class DidntFinishThis
def initialize(name)
@name = name
@banking_info = "TOP SECRET!!"
end
# Let's make it so I can arbitrarily add methods at runtime!
# That seems like a safe and sane idea!
def method_missing(method, *args, &block)
super unless (method.to_s =~ /^addmethod_\w+/)
method_name = method.to_s[/(?<=_)\w+/]
define_singleton_method(method_name) { |*args| block.call(*args) }
end
end
obj = DidntFinishThis.new("obj")
# Oh whoops, I 'forgot' to add the method back when I was writing
# the class. Oh well, I can just do it now!
obj.addmethod_say_hello do |name, greeting|
my_name = obj.instance_variable_get("@name")
puts "#{greeting}, #{name}! I am #{my_name}!"
puts "By the way my internals are: #{obj.instance_variables.to_s}"
end
# So convenient! And absolutely no downsides whatsoever!
obj.say_hello("everyone", "Hello")
#=> Hello, everyone! I am obj!
#=> By the way my internals are: [:@name, :@banking_info]
# No, wait! Uh-oh! Abort!!!
obj.addmethod_get_banking_info() do
my_banking_info = obj.instance_variable_get("@banking_info")
puts "My banking info is #{my_banking_info}!"
end
Assuming you don't already know programming this is the most bizarre list of "first languages" I've ever seen.
Interesting that you bring that up in relation to Java. A thought just hit me: is the JVM a very advanced Lisp machine? Or more correctly, a SECD machine? Something here is scratching at the back of my mind. JVM bytecode is all about stack operations. SECD? Forth? We have to investigate.
The JVM doesn't have an instruction for tail-calls, which forever cripples recursion, so no. The JVM is a very stupid platform on which to run anything calling itself Lisp. The CLR is better.