Isn’t problem solving mostly put things together of what you’ve learned before?
I didn’t read everything, but I mostly agree with the author, especially on this point:
While you can definitely abuse exceptions, functional-style error values are not a one-size-fits-all solution.
There are time and place for both. I think exceptions are good for bigger errors. Like database connection errors. Things that shouldn’t happen without any easy backup plan. Those errors might need to be escalated as high as possible where proper action can be made (like resetting the database connection and everything relying on it).
Functional style is great for smaller stuff. Like key not found in hash maps. In many cases there might be good defaults that can be used instead.
It’s a concept of a plan
Haven’t read through this, but this sounds like what C++ is to C. I’m not sure adding more complexity and features to an already complex language is the right way forward. What is needed is a language that cuts down all the burden that has accumulated in C++ over 3 decades.
Something like Zig sounds like the better path forward to me. A completely new language from scratch with cross interoperability to C++. I’m surprised it’s not mentioned even once in the page.
I agree that people shouldn’t have to die over this, but Putin is dedicated to the invasion on Ukraine. He won’t stop just because someone kindly ask him to stop over the phone. He’ll continue until there’s no Ukraine anymore, and then he might also go for Moldova and other former Soviet countries.
Ukraine has to defend themselves for as long as Putin is willing to continue the war.
Go tell Putin and his friends to stop the invasion and hand back all the Ukrainian territory they’ve stolen. It’s easy!
Yes, I think so. The downside with Python comes when refactoring the code. There’s always this double checking if the code is correctly indented after the refactor. Sometimes small mistakes creep in.
It’s really hard to tell when Python code is incorrectly indented. It’s often still valid Python code, but you can’t tell if it’s wrong unless you know the intention of the code.
In order languages it’s always obvious when code is incorrectly indented. There’s no ambiguity.
I don’t like YAML because it’s overly complicated. The specification is like 80 pages long. How the hell did they think that was a good idea?
JSON on the other hand is super simple. It doesn’t do more than it needs to.
Just compare this: https://yaml.org/spec/1.2.2/
With this: https://www.json.org/json-en.html
The entire JSON specification is shorter than just the table of contents of the YAML specification!
Another thing I like about JSON is that you can format it however you want with the whitespace. Want everything on one line? Just write everything on one line!
If data can be represented as a JSON, then there’s generally only one way to represent it in JSON (apart from whitespace). In YAML the same data can be represented in 1000s of different ways. You pick one.
It was featured in a PlayStation showcase last year. The most notable part of the trailer was a burger. I’m not kidding.
Joseph Anderson has made a similar trolley challenge. It’s a cinematic masterpiece: https://youtu.be/RgqRIFj4Zrk
Right now I’m mostly using the Xbox One controller (on PC). It’s a controller that feels really good to hold. No weird gimmicks like motion control either. I think it’s one of the all time greats.
Runner up is GameCube.
Shit in terms of having no players and being pulled back after just two weeks.
From what I understand, the game itself was alright. It had no major technical or gameplay problems. At least the team of programmers and game designers were competent.
The main issue is that the game was incredibly unappealing, and I believe this can only come from poor leadership.
It’s probably not even the artists fault it turned out this shit. My gut feeling is that the game is victim of incompetent leadership. Indecisiveness on important matters and micro management on stupid things.
It’s also the same incompetent leadership who will get bonuses and promotions after this.
The only problem is to ensure the entire team agrees to only use it like an interface and nothing else. But I guess that’s the only proper way to do it in C++, for now.
In your example, the declaration of ArrayList look like:
public class ArrayList extends AbstractList implements List {
}
The dependence on AbstractList is public. Any public method in AbstractList is also accessible from the outside. It opens up for tricky dependencies that can be difficult to unravel.
Compare it with my solution:
public class ArrayList implements List {
private AbstractList = new AbstractList();
}
Nothing about the internals of ArrayList is exposed. You’re free to change the internals however you want. There’s no chance any outside code will depend on this implementation detail.
If the lists have shared components then that can be solved with composition. It’s semantically the same as using abstract classes, but with the difference that this code dependency doesn’t need to be exposed to the outside. This makes the dependency more loosely coupled.
I usually break it out using composition if that’s ever needed. Either by wrapping around all the implementations, or as a separate component that is injected into each implementation.
Ask Bjarne to add interfaces enough many times until he gives in.
On a more serious note, I’m not exactly sure what the best C++ practice is. I guess you just have to live with abstract classes if you really want interfaces.
What’s happening is that support from VC money is drying up. Tech companies have for a long time survived on the promise that they will eventually be much more profitable in the future. It doesn’t matter if it’s not profitable today. They will be in the future.
Now we’re in a period where there’s more pressure on tech companies to be profitable today. That’s why they’re going for such anti consumer behaviors. They want to make more with less.
I’m not sure if there’s a bubble bursting. It could just be a plateau.