wangchow

My point is, a lot of people are spending time on this when it doesn't matter. In the limit that AI starts replacing human developers these subtle differences in language approaches zero.

New languages here and there every day. Replace this replace that. When, in the end everyone is simply reinventing the "wheel" over-and-over.

All these languages end up as assembly.

Honestly, we need a few AI coders to replace most of the developers in the world and then this won't be an issue. Bounds checking arrays and calloc instead of malloc isn't rocket science. It's a simple formula.

The problem isn't the language it's the developers.

I tend to read undefined as don't do it

Source code is the ultimate documentation. ;)

Solar is better because it is decentralized whereas other sources we have today are controlled by single entities. This puts the power (hehe) back in the hands of the people.

GC is certainly easier. However, it is important to understand the life-cycle of objects regardless. To be able to control them (if desired) is good because in many cases one would prefer to have that control instead of being forced to use garbage collector.

In an ideal world, garbage collector makes sense because we don't want to have to worry about life-cycle management when we are solving other problems. Memory management can indeed be an annoying implementation detail, but as it stands there are certainly limiting factors in hardware which are impacted by generic object-management for specific application domains.

To the contrary, as someone who hasn't used TeX at all I find it somewhat hard to read the plain-text. The $$$ have more visual weight than the actual formulas.

Kind of interesting to see some alternatives and note the visual weight. The back-ticks are by far the best in my opinion. Too bad they are taken by the code blocks! Semicolons are nice though--kind of like a LISP comment.

@@ x^2 + 4x = 10 @@

%% x^2 + 4x = 10 %%

<< x^2 + 4x = 10 >>

$$ x^2 + 4x = 10 $$

`` x^2 + 4x = 10 ``

'' x^2 + 4x = 10 ''

"" x^2 + 4x = 10 ""

;; x^2 + 4x = 10 ;;

\\ x^2 + 4x = 10 //

?? x^2 + 4x = 10 ??

Ah, wasn't aware of that. Thanks. :)

Very awesome. However, the $ signs indicate financial stuff. It would be nice to have a different delimiter like the code blocks use back-tics. For example using back-ticks couple with single-quotes? It doesn't work since it clash with the code block just for example more legible:

`' x^2 + 4x + 4 '`

Remember: the whole idea behind markdown is it should be first and foremost* legible from plain-text. One idea behind typography is it shouldn't be noticed at all to the reader.

And most humans are lazy f%$#s who throw things away rather than recycling them.

What about smart pointers? It gives the flexibility and benefits of garbage-collection without the performance degradation. It's not a silver bullet but it helps.

What I'm getting at is, Rust is the only modern language (in vogue at the moment) that does not use garbage collection. It would be nice if more languages didn't require a garbage collector but gave the option to use one.

If there are some more of such languages please chime in and provide a link to them! :)

Alas, having no garbage collector at all is a blissful state of simplicity when performance matters. It's not very difficult to clean up one's objects manually in a well-thought-out codebase.

I think it's more about the underlying machine as opposed to a particular language implemented on top of Von Neumann architecture. For instance, we are constrained by the underlying machine regardless of which higher-level language we use, functional or otherwise.

I started reading this book on functional languages and lambda calculus. It has some interesting notes on how to build language syntax on top of a purely-functional machine architecture (at least conceptually). Pretty interesting stuff:

[An Introduction to Functional Programming Through Lambda Calculus](http://store.doverpublications.com/0486478831.html)

Very well put. I have to agree that these technologies are still blooming and there are uncertainties--especially in my mind with cost associated with buying devices. Hololense for example with a $3000.00 USD developer edition isn't exactly accessible to the general community! The next 10 years however will probably be pretty exciting in the AR/VR space.

What about voice-controlled programming though? I always thought it would be nice to voice-control my OS. Not specifically for a text-editor, but as a general interface to the OS. It would be nice to move these features out of the cloud and directly onto systems. But then again, a lot of companies (amazon, microsoft, apple) probably don't want to encourage reverse-engineering of their intellectual property. We definitely need open-source variants.

Better AI chips with lower power-consumption and optimization for these types of operations will hopefully usher in a new set of productivity-enhancing applications!

Sorry I was having a silly day at work. Then, I tried to delete the post but I cannot anymore!

EDIT: But Zuckerberg is a peener when he states that fake news is fake; he's drinking his own Koolaid.

Well consider if you use both dictation and typing simultaneously. Vi and kakoune are ergonomic because it requires minimum changes to hand positions. But if you added voice dictation like "toggle tab 2" or "toggle terminal" or "go next brace" etc, all while STILL typing my guess is efficiency would go up physical fatigue would go down.

In this age we need to think about things like voice control and 3D manipulation of data-structures and a dynamic view of the code.

We can truthfully keep designing 2D editors (and we will always most likely use them to some extent) but I believe it is more important to consider different UI paradigms altogether.

For instance, what about editing a living code environment? Game development is very immersive: you can manipulate a running environment and see results immediately. How can this be extended to other development tasks like server-side development?

What if, when you select a for loop from code fragment a 3D visualization of the programs data structures at that point is shown to the user. What if you can, instead of launching a debugger, run the debugger as you're writing the code and step forward and back and see these visualizations change?

We have all the technology. It's time to get to the next level.

Tcl (upon which Expect is built) is under-appreciated too. It's a neat language how strings behave as a sort of polymorphic data structure (can be dicts, lists, etc). Under the hood they get optimized based on usage.

To me computer skills means two things: rate at which one can learn new technologies, and one's understanding the basic components that comprise of the machines.

Programming fits both of those categories: consider the number of programming languages in vogue at the moment. These languages however are composed of the same components which comprise the machine.

Programming languages are software, no differently than iMessage or Windows Live Mail. It's just another way to control the machine.

Also would like to sync to cloud of our choosing. Dropbox, box, one drive, adobe cloud, etc. I am not a fan of having to use a million cloud services these days.

You would not get nonsense, you would get emotional charge. Emotions can easily overpower thought-process. Because of this, emotional charge is the de facto force of social change.

In that context doping is considered damaging to the country's reputation (to my other point) and should be deemed illegal. Or at least until biological enhancements become widespread and the games become too ordinary. :)

Well there's massive protests going on to oust their president.

http://www.reuters.com/news/picture/massive-protests-against...

Or perhaps like taking performance-enhancing drugs as an Olympian. But you just get disqualified from the games not thrown in jail.

Arguably though it's sabotaging the experience for other players which can be thought of as damages to the company directly.

And.. While they express such distaste the haters probably serve their web apps via NGINX.

A time will come when our entire concept of programming will shift due to advances in hardware unlike what we have today. Consider quantum computers or some biological machine etc.

Those who use C and assembly I imagine would be better equipped to understand the new paradigms. It's best to understand how to implement data structures in their most rudimentary form because implementing them on new platforms becomes easier.

In addition, higher-level idioms become easy to understand if the parts that make up the whole are understood. And underneath all those layers of translation and compilation we have raw assembly and the bare machine.

Gnunet on the right track: https://gnunet.org/

Maybe there's an experimental feature that can be enabled to get it.

I have used mostly the class diagrams and sequence diagrams.

I like how UML class diagrams defines the different potential relations between objects involved in software.

It would be nice if more people (myself included) learned better ways to consistently communicate software design. Lots of ad-hoc meetings result in confusion because often a design is scribbled in ones own notation then communication takes longer. But yet such communication is crucial to large projects.

Some call it architecture, others call it design patterns. Either way its important to have thought-out, standard ways to communicate ideas.

With the security sandbox of the browser functionality is inherently limited (by design) compared to native apps which have less-limiting restrictions.

Security and usability are inversely proportional and the browser needs that security more than anything else.

That being said, it's great to see the innovation in the web space. But it will always be limited to specific application domains and the standards move slowly