And memory bugs are only a subset of bugs that can be exploited in a program. Pretending Rust means no more exploitation is stupid.
This is facile.
According to Microsoft, about 70% of security bugs they see are memory safety issues.
Yes: if you introduce memory safety, there’s still those 30% of security bugs left. But, well, I’d rather worry about 30% of issues than 100%…
Similarly, I use libraries that eliminate SQL injections unless you really go out of your way.
Although it’s been used for a fairly wide array of algorithms for decades. Everything from alpha-beta tree search to k-nearest-neighbors to decision forests to neural nets are considered AI.
Edit: The paper is called
Avoiding fusion plasma tearing instability with deep reinforcement learning
Reinforcement learning and deep neural nets are buzzwordy these days, but neural nets have been an AI thing for decades and decades.
Symbols display with friendly string-y names in a number of languages. Clojure, for example, has a symbol type.
And a number of languages display friendly strings for enumy things - Scala, Haskell, and Rust spring to mind.
The problem with strings over enums with a nice debugging display is that the string type is too wide. Strings don’t tell you what values are valid, strings don’t catch typos at compile time, and they’re murder when refactoring.
Clojure symbols are good at differentiation between symbolly things and strings, though they don’t catch typos.
The other problem the article mentions is strings over a proper struct/adt/class hierarchy is that strings don’t really have any structure to them. Concatenating strings is brittle compared to building up an AST then rendering it at the end.
Edit: autocorrect messed a few things up I didn’t catch.
Suppose one year you spend $60k, but only earned $50k. You lost $10k.
The next year, you spend $57k, and earned $53k. You lost $4k, and your losses narrowed by $6k.
Disney+ lost 1.3 million subscribers in the final quarter of 2023 amid a hefty price hike that went into effect last fall, but managed to narrow its streaming business’ losses by $300 million during the October-December period.
That doesn’t really sound like it backfired to me. They lost subscribers but made more money.
Javascript is generally considered OOP, but classes weren’t widely available till 2017.
Inheritance isn’t fundamental to OOP, and neither are interfaces. You can have a duck- typed OOP language without inheritance, although I don’t know of any off the top of my head.
Honestly, the more fundamental thing about OOP is that it’s a programming style built around objects. Sometimes OO languages are class based, or duck typing based, etc. But you’ll always have your data carrying around it’s behavior at runtime.
keeping state (data) and behavior (functions) that operate on that state, together
Importantly, that’s “together at runtime”, not in terms of code organization. One of the important things about an object is that it has dynamic dispatch. Your object is a pointer both to the data itself and to the implementation that works on that data.
There’s a similar idea that’s a bit different that you see in Haskell, Scala, and Rust - what Haskell calls type classes. Rust gives it a veneer of OO syntax, but the semantics themselves are interestingly different.
In particular, the key of type classes is keeping data and behavior separate. The language itself is responsible for automagically passing in the behavior.
So in Scala, you could do something like
def sum[A](values: List[A])(implicit numDict: Num[A]) = values.fold(numDict.+)(numDict.zero)
Or
def sum[A: Num](values: List[A]) = values.fold(_ + _)(zero)
Given a Num typeclass that encapsulates numeric operations. There’s a few important differences:
All of the items of that list have to be the same type of number - they’re all Ints or all Doubles or something
It’s a list of primitive numbers and the implementation is kept separate - no need for boxing and unboxing.
Even if that list is empty, you still have access to the implementation, so you can return a type-appropriate zero value
Generic types can conditionally implement a typeclass. For example, you can make an Eq instance for List[A] if A has an Eq instance. So you can compare List[Int] for equality, but not List[Int => Int].
Oh, yeah.
If your point is that ICE car batteries have problems in the cold, so cold batteries is a problem for everyone and worse for ICE cars, that’s fair.
If your point is that ICE car batteries suck therefore EVs suck, that’s not really valid logic.
Lead-acid batteries aren’t lithium ion? And the car starter battery isn’t equivalent to that of an EV?
You might as well say that I have trouble starting my gas weed wacker, therefore cars are hard to start.
Apparently my brain silently inserted “ing with” into the middle of “program functions” a half dozen times without me noticing.
It’s really not just that Rust is new and C is old. Compare Rust with Go, for example. Go is a fairly modern example of a ‘worse is better’ language.
Back in 1970s when C was invented, Lisp had been around for over a decade. C came out the same year as smalltalk, a year before ML, and 3 years before Scheme.
Rust is a very modern language, yes. There’s no way we could have had it in the 70s; many of its language features hadn’t been invented yet. But it very much depends on MIT style research languages for its basis.
I agree with you that if you use functions it’s functional.
But many people don’t really realize how that contrasts with procedures and procedural code.
Functions, here, being the key word.
Functions are pure mappings from input to output.
C is many things, but elegant really isn’t one of them.
C has always been part of the “worse is better”/New Jersey school of thinking. The ultimate goal is simplicity. Particularly simplicity of language implementation, even if that makes programs written in that language more complex or error prone. It’s historically been a very successful approach.
Rust, on the other hand, is part of “The Right Thing”/MIT approach. Simplicity is good, but it’s more important to be correct and complete even if it complicates things a bit.
I don’t really think of void* and ubiquitous nulls, for example, as the hallmark of elegance, but as pretty simple, kludgey solutions.
Rust, on the other hand, brings a lot of really elegant solutions from ML- family languages to a systems language. So you get algebraic data types, pattern matching, non-nullable references by default, closures, typeclasses, expression-oriented syntax, etc.
Just like walking doesn’t really compete, like at all, with flying in an aircraft, Functional and Object Oriented Programming are at their best when you use whichever approach makes sense for a given situation and in any reasonably complex software that means your code should be full of both.
I’m not really sure sure that’s true.
In FP languages like Haskell, you get tools like algebraic data types, typeclasses, and pattern matching.
FP is really opposed to imperative programming, while objects are opposed to algebraic data types.
You can write OO code that’s 100% fully functional, and you can write code in Haskell or rust where you barely notice you never once used an object.
Yeah, OO and FP aren’t really opposed. FP is opposed to imperative programming.
That said, most FP languages give you a slightly different set of tools to use. Algebraic data types and typeclasses are really, really nice.
Honestly, working in Haskell or rust, you don’t really miss the fact that you have to jump through hoops to get traditional OO objects. There’s just not really many cases where you need them.
The main problem is just that getting a product from a one-off in a lab to a cost-competitive mass-market product is hard and can take a lot of time, to say the least.
For example, Don Sadoway initially published about a molten metal battery in 2009. He gave a Ted talk in 2012. They’ve run into assorted setbacks along the way and are apparently just starting to deploy the first commercial test systems this year.
It’s less that these breakthroughs are bullshit, and more that commercializing these things is hard. The articles about the breakthroughs are often bullshit, though, or at least way too rosy.
In the US, at least, AI works are inherently public domain. Because copyright only applies to works with a human author.
Nope. The idea in no till is just adding stuff to the top and letting worms and roots handle the tilling.
I’ve had good luck just dumping a foot or two of finished compost on the ground and growing in it.
Another solid no-till approach is sheet mulching. You put down a layer of cardboard (to kill weeds), then layers of carbon and nitrogen like straw and kitchen scraps. Wait a few months, then plant. So you could do that in the late summer or fall to prepare a site for spring planting.
A lot of these things depend on location, though. Something that works great in Pennsylvania might not work as well in Utah.
Yeah. Power plants are nowhere near 90% efficient.
It’s worth emphasizing, though, that they’re still way, way more efficient than car engines are.
Also, regenerative breaking saves a lot of energy. Basically, instead of using the motor to increase the cars speed, you use it as a generator to recharge the battery.