dmux

It reminds me of a great quote from the book Computing Fundamentals [0] regarding Wirth's design philosophy:

>Wirth’s philosophy of programming languages is that a complex language is not required to solve a complex problem. On the contrary, he believes that l languages containing complex features whose purposes are to solve complex problems actually hinder the problem solving effort. The idea is that it is difficult enough for a programmer to solve a complex problem without having to also cope with the complexity of the language. Having a simple programming language as a tool reduces the total complexity of the problem to be solved.

[0] https://www.cslab.pepperdine.edu/warford/ComputingFundamenta...

What's the protocol if the phone (or other electronic device) was provided to you by your employer? Wouldn't unlocking and handing over a "protected" device be against most company handbooks?

AFAIK, Groovy 3 is targeting Antlr 4.

It's also common for towing companies to show up to the scene of an accident before police arrive with hopes of convincing those in the accident their vehicles need to be towed for some reason or another. Canada has even gone as far as implementing new laws to prevent this.

I believe Infinite Jest uses "endnotes" as opposed to footnotes. One interesting example of footnotes is Mark Z. Danielewski's House of Leaves where different narrators make extensive use of footnotes to add additional details to the story. On many occasions, the "base" story is only a single paragraph and the footnotes will run on for dozens of pages.

>Does any other language even come close to this?

Smalltalk

Could you explain why adding to the end of an array results in O(n^2)? From what I can find, it appears to be O(1). If you increase the size of the array by 1 each time and copy the old array elements over, wouldn't that be O(n) to copy the array plus the additional add, O(n+1) which is just O(n)?

Would setting up an LLC for yourself help protect some of those rights?

I've always found it really interesting how some people's jobs is to not only research historic artifacts, but research and verify what they had found out was accurate and repeatable. What kind of background do these people have that they can get into this line of work?

Likewise with Apache Groovy, which has optional typing:

    #!/usr/bin/env groovy
    // @Grab annotation won't work in scripts
    import static groovy.grape.Grape.grab
    grab(group: 'org.apache.commons', module: 'commons-csv', version: '1.5')
    
    println "Starting to parse CSV"

I once worked with a software system where the preferred way of interacting with its admin features was using lynx. It's a great way to provide menu-based software configuration.

Would a factory be able to achieve this? Keep a reference to everything it had constructed?

Ever Wonder Why? by Thomas Sowell

Non Violent Communication by Marshall B. Rosenberg

(1) Object Thinking by David West. (2) Thinking Forth by Leo Brodie

We're currently using Groovy and Grails deployed within Docker containers to ECS.

>There's tons of waste in all human endeavor

I believe the argument stems from the difference between wasting your own money vs. wasting tax payer money.

>but I haven't seen any evidence that government is particularly good or bad

There's plenty of examples out there of the latter (you'll often see more criticism than praise on govt spending). For example, [1].

[1] https://www.heritage.org/budget-and-spending/report/50-examp...

Athenahealth

>you build and test your app live and then dump it all to a text file

The Tcl shell is really great for doing this. Since everything can be represented as a string-type, you're able to introspect your defined procedures and dump them to disk.

From https://nim-lang.org/features.html:

> Oberon-inspired visibility markers

> Pascal-inspired type sections for leaner definitions

While Oberon isn't Pascal, they're both Wirth languages that share many commonalities.

Isn't setAccessible required before you can interact with fields?

Understanding Computation by Tom Stuart [0]. While not soley dedicated to creating a language, the first couple of chapters deal with building semantics of a simple language using Ruby as the implementation language (but easily done in any other language you're familiar with). Implementing the virtual-machine the language runs upon in a language you already know provides some really wonderful insights.

[0] http://a.co/7MI5j7h

> ... that is structured well ...

Is there a way to organize a large program (let's say in Java) that allows one to easily extract specific components and move them to their own service as needed? I'm thinking along the lines of local message passing between Java "components" (not packages). With a message system in place, you could easily move a service wherever so long as it's able to communicate.

Object Thinking by David West

I posted a link to a paper [0] about "Deliberate Performance" the other day that some may find useful. In that paper -- along with making the distinction between practice and performance -- they describe deliberate performance as:

>the effort to increase domain expertise while engaged in routine work activity.

They then go on to give four types of exercises to focus on: repetition, timely feedback, task variety, and progressive difficulty.

[0] http://peterfadde.com/Research/Deliberate_Performance-PI-101...

I'd be interested in hearing what the community has to say regarding static types and whether or not they're compatible with object-oriented programming. I've posted this link a couple times before, but it hasn't been actively discussed: https://essencesharp.wordpress.com/2014/07/17/static-typing-...

From that article:

"Static typing inhibits interoperability. It does so between class libraries and their clients, and also between programming languages.

The reason is simply because static typing violates encapsulation in general, and improperly propagates constraints that aren’t justifiable as architectural, design or implementation requirements in particular. It does so either by binding too early, or by binding (requiring) more than it should."

> I find static strong typing speeds me up because I don't have to restart the app, click some buttons etc.

I'd blame this more on our current programming environments than anything. Smalltalk is exceptionally productive and doesn't require restarting to test things.

I've been working on a Realty Broker (common in Boston) idea for the past couple of months. I'd say the problem of finding people isn't that difficult really. I've built a list of 75+ companies including their contact info, website, location, etc. My next step is to go down the list and essentially cold call them. My plan is to ask what software they're currently using (if any); whether it meets all their needs -- if not, what are they looking for; etc. If anything, I hope to at least help a couple of them get a website up and running and start from there.

>The compiler can also be directed to perform whole-program compilation, which does full cross-library optimization and also reduces a program and the libraries upon which it depends to a single binary.

Does anyone know if this involves "tree-shaking" to remove unused code; or is it simply creating a binary with all dependencies as stated?

There was a previous HN discussion about this: "Chez Scheme as the Racket VM" [0] which you may find insightful.

That discussion links to a Google Groups page where Matthew Flatt discusses the background, status and plan going forward.

[0] https://news.ycombinator.com/item?id=13656397

Too bad malls are on the decline.