Esoteric programming paradigms - <AUTHOR> http://www.ybrikman.com/writing/2014/04/09/six-programming-paradigms-that-will/ <comment><USER2> I have two comments about the Prolog code:

First, the article claims: "the sudoku solver above does a brute force search", but that is specifically _not_ the case. In fact, quite the _opposite_ holds: The Prolog Sudoku formulation shown in the article uses a powerful technique known as Constraint Logic Programming over Finite Domains, which automatically performs _pruning_ before and also _during_ the search for solutions. This effectively eliminates large portions of the search space in practice, and degenerates to brute force _only_ in those cases where almost nothing can be deduced from initial constraints. In the particular case of Sudoku, the pruning is especially effective and can in many cases _eliminate the search entirely_ , since the initial constraints (hints) basically determine the whole solution.

Second, yes, it is easy to write an O(n!) search algorithm in Prolog. However, it is almost as easy to implement _much more efficient_ search algorithms in Prolog. For example, here is Quicksort in Prolog:

        quicksort([])     --> [].
        quicksort([L|Ls]) -->
                { partition(Ls, L, Smalls, Bigs) },
                quicksort(Smalls), [L], quicksort(Bigs).

Note how natural the declarative description of "first the smaller elements, then the pivot element, then the bigger elements" is in Prolog. This only requires a suitable implementation of partition/4, which is very easy to implement in at most 7 lines of Prolog code.

<comment><USER3> I think you are just using a different definition of brute force than the post is using. It doesn't try all permutations of the digits, but it does do a search over the tree to find the solutions.

Now, to your point, this is really the only way you can solve sudoku. There is an odd belief that you can make an algorithm that "never guesses." And folks think that that would be the definition of a non-brute force algorithm. In reality, you either have a solver that is ready to backtrack, or you have one that can't solve all puzzles.

<comment><USER4> I am not sure about your backtracking point. Sudoku can be solved by Integer Programming (i.e. a special subset of Linear Programming) and this does not require any kind of backtracking.

<comment><USER3> While I wouldn't be shocked to know that I'm wrong on requiring backtracking, I am not sure how the integer programming claim refutes it. In particular, those look to still be "search" solvers and almost certainly have to perform some "guess" in making the search.

Do you happen to have a recommended link on how this can be accomplished? First few results in searching just show farming this out to a specialized function in matlab. :)

<comment><USER4> It is a bit difficult to explain Linear Programming in a forum post (so I will have to default to Wikipedia: [https://en.wikipedia.org/wiki/Linear_programming](https://en.wikipedia.org/wiki/Linear_programming) or to provide a link to a nice MOOC: [https://www.edx.org/course/optimization- methods-business-ana...](https://www.edx.org/course/optimization-methods- business-analytics-mitx-15-053x)).

There is absolutely no "guessing" involved, though: you describe your sudoku problem as a series of linear equations (which represent the edges of your search space) and then the algorithm travels from one vertex to the next until it finds the solution. There is no backtracking at all.

<comment><USER5> While this may be true for linear programming, is it true for integer linear programming or binary integer programming, which one would presumably use to model Soduku? The Wikipedia article you posted claims that integer programming problems are NP-hard.

> If all of the unknown variables are required to be integers, then the > problem is called an integer programming (IP) or integer linear programming > (ILP) problem. In contrast to linear programming, which can be solved > efficiently in the worst case, integer programming problems are in many > practical situations (those with bounded variables) NP-hard. 0-1 integer > programming or binary integer programming (BIP) is the special case of > integer programming where variables are required to be 0 or 1 (rather than > arbitrary integers). This problem is also classified as NP-hard, and in fact > the decision version was one of Karp's 21 NP-complete problems.

Here is an article on the topic of "Binary and Mixed Integer Programming" which explains part of the Balas Additive Algorithm (infeasibility pruning, I believe) in terms of backtracking:

> At this point, both of the nodes just created are not eligible for further > expansion, so we back up the tree, looking for a level at which one of the > nodes is unexplored.

[http://www.sce.carleton.ca/faculty/chinneck/po/Chapter13.pdf](http://www.sce.carleton.ca/faculty/chinneck/po/Chapter13.pdf)

Another paper describes a method by Glover characterized as "A backtracking procedure for implicit enumeration".

> A particularization of the procedure based on Balas' algorithm. In S2 we > presented and justified a flexible and economical back-tracking procedure > for finding an optimal feasible solution of (P) by implicit enumeration.

See Figure 1 on page 182 (or page 6 in the PDF):

[http://www.anderson.ucla.edu/faculty/art.geoffrion/home/docs...](http://www.anderson.ucla.edu/faculty/art.geoffrion/home/docs/e7.pdf)

This branch of mathematics is not my forte however, so if I've misunderstood then I'd appreciate clarification. It seems like the algorithm is not backtracking in the sense of generating possible solutions and checking them, but is backtracking in the sense of fathoming which next cheapest (partial) solution might be feasible, and abandoning it if proven to be definitely infeasible, in favor of examining the (then) next cheapest potential solution.

Finally, see the following paper that compares and contrasts Constraint Programming with Integer Programming, and characterizes both of them as instances of Tree Search:

[http://preserve.lehigh.edu/cgi/viewcontent.cgi?article=1780&...](http://preserve.lehigh.edu/cgi/viewcontent.cgi?article=1780&context=etd)

<comment><USER4> _Extremely Coarse Approximation Alert_

Try to imagine this: by manipulating an n-dimensional matrix in a certain way, you get, at each step, a result which is guaranteed to be part of your solution space. You also have a way to find out, at each step, if you have found the optimal solution (in terms of your objective function) or if no solution exists.

So the process goes like this: Put your constraints in the matrix.

      Loop -
        Manipulate Matrix
        Is this the optimal Solution?
          Yes - return solution
        Is the solution space empty/concave/unbound?
          Yes - return error
      End.

No backtracking in the sense of "try this... hmm... no, try this other".

I have used LP professionally in the past, and recently participated in the MOOC I linked above (as a refresher) but I might surely be missing something (the theory I studied at UNI too many years ago - now I just use it as a tool) or overgeneralizing too much. If anyone can provide corrections these will be welcomed.

<comment><USER5> Could you clarify which algorithm you're referring to? Or name an example algorithm that works in the way you describe? What I find in academic literature seems to characterize Integer Programming as a search problem. See the following article that compares Constraint Programming with Integer Programming:

[http://preserve.lehigh.edu/cgi/viewcontent.cgi?article=1780&...](http://preserve.lehigh.edu/cgi/viewcontent.cgi?article=1780&context=etd)

> Since tree search is a basic solution technique employed in both constraint > and integer programming, we begin with a generic overview of tree search as > a technique for finding feasible solutions to mathematical models.

> Every tree search algorithm is defined by four elements: a node- processing > procedure, pruning rules, branching rules, and search strategy. The > processing step is applied at every node of the search tree beginning with > the root node, and usually involves some attempt to further reduce the > feasible set associated with the node by applying logical rules. [...]

> One particularly well-developed solution technique, called branch and bound, > was introduced by Land and Doig. Branch and bound is frequently used to find > solutions to integer programming problems; it is a tree search procedure in > which a bound on the optimal value to each subproblem is obtained by solving > a relaxation. In this thesis we assume the use of a linear programming > relaxation in the branch and bound tree.

> The last piece of a branch and bound algorithm is a search strategy > specifying the order in which to explore nodes of the tree. Depth-first > search can be used to save memory in a branch and bound tree, since we must > only remember the difference in solution between two successive nodes of the > search tree.

Chapter nine of Applied Mathematical Programming from MIT classifies integer program solvers into three major groups:

[http://web.mit.edu/15.053/www/AMP- Chapter-09.pdf](http://web.mit.edu/15.053/www/AMP-Chapter-09.pdf)

> Whereas the simplex method is effective for solving linear programs, there > is no single technique for solving integer programs. Instead, a number of > procedures have been developed, and the performance of any particular > technique appears to be highly problem-dependent. Methods to date can be > classified broadly as following one of three approaches:

> i) enumeration techniques, including the branch-and-bound procedure;

> ii) cutting-plane techniques; and

> iii) group-theoretic techniques. [...]

> Branch-and-bound is essentially a strategy of ''divide and conquer.'' The > idea is to partition the feasible region into more manageable subdivisions > and then, if required, to further partition the subdivisions. In general, > there are a number of ways to divide the feasible region, and as a > consequence there are a number of branch-and-bound algorithms.

> An integer linear program is a linear program further constrained by the > integrality restrictions. Thus, in a maximization problem, the value of the > objective function, at the linear-program optimum, will always be an upper > bound on the optimal integer-programming objective. In addition, any integer > feasible point is always a lower bound on the optimal linear-program > objective value. The idea of branch-and-bound is to utilize these > observations to systematically subdivide the linear programming feasible > region and make assessments of the integer-programming problem based upon > these subdivisions.

The book describes the "cutting-plane" approach, which does seem to work more like how you're describing (a series of transformations), but also says:

> In practice, the branch-and-bound procedures almost always outperform the > cutting-plane algorithm. Nevertheless, the algorithm has been important to > the evolution of integer programming. Historically, it was the first > algorithm developed for integer programming that could be proved to converge > in a finite number of steps. In addition, even though the algorithm > generally is considered to be very inefficient, it has provided insights > into integer programming that have led to other, more efficient, algorithms.

<comment><USER4> As I mentioned elsewhere, it has been ages since I took an actual formal exam on Linear Programming (and Integer Programming) - since then I always used dedicated sw to solve LP (there is for example a nice, self-contained LP solver in _Numerical Recipes in C_ ) and so I always focused more on how to describe the problems in terms of linear constraints.

"In my mind" it works like this: [https://www.quora.com/What-is-the- difference-between-integer...](https://www.quora.com/What-is-the-difference- between-integer-programming-and-linear-programming)

Having said this, while NP is guaranteed to terminate the actual computation time may take ages. Integer Programming may very well leverage the fact that the solution is restricted to integer values and apply different, faster algorithm to exploit this property - including search trees. But in the most general sense you do not need a search tree or backtracking for Linear Programming.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER6> 'Concurrency-by-default' is similar to a notation I've been using to map out async service calls. It's just this: lines are terminated with "," or ";". A comma doesn't block and all comma-separated lines are executed in any order, while a semicolon blocks. Names are only usable when a semicolon is reached, and a semicolon unblocks flow when all preceding names are bound. Probably code is scoped into { } blocks. So a lambda is like "pyth_distance = {x, y; sqrt(x^2 + y^2)}". A series of async callbacks would be given by an inner block {x = call1(), y = call2(); pyth_distance(x,y)}, allowing you to do any manipulations you can do with normal code.

Might try making a toy language out of it eventually.

<comment> aaron-lebo That's really cool.

Would you build something like this from scratch or base it on another tech stack like the jvm?

<comment><USER7> That's exactly what || (concurrent statements) and ; (sequential statements) do in Esterel.

<comment> aaron-lebo Thanks, was totally unaware of that. For the lazy and ignorant like me:

[https://en.wikipedia.org/wiki/Esterel](https://en.wikipedia.org/wiki/Esterel)

(if you'd like to throw a link in your comment, would be happy to delete this one)

<comment><USER7> No need :) But I'll happily add this one, which is a nice short intro if you know nothing about it: [http://www.embedded.com/design/prototyping-and- development/4...](http://www.embedded.com/design/prototyping-and- development/4024644/An-Introduction-to-Esterel)

I came in contact with the language during my studies (one of my profs worked on it), found it interesting, but haven't really had a chance to apply it to anything I've done professionally since. It's a very neat language though, and if I got to do anything in the embedded field.

I notice that there is now an open source compiler, which is great. The only implementation I was aware of so far was closed source.

</comment></comment></comment></comment></comment><comment><USER8> I don't know if Prolog should be called esoteric. Prolog is an ISO- standardized language after all, and its syntax has been used for 4+ decades now in most papers on conceptual database system and query language design I've read. Which isn't surprising since Prolog syntax, being based on operator-precedence grammar concepts, is arguably as minimalistic as it gets. There's definitely also a lot of interest lately in Datalog, not just as a decidable logic fragment (which has been used for decades as well), but also as a practical non-SQL database query language and proper Prolog syntax subset.

<comment> fake-name Considering they also mention SQL and Forth, I think this could probably equally be called "things that confuse someone who only knows C".

<comment><USER9> I think both Forth and SQL are outliers in their strangeness. Most people only have to deal with SQL on a very shallow level and barely regard it as programming at all.

Forth is known by name and reputation but very few people have ever tried to write anything in it - let alone delve into it's strange bootstrapped nature.

<comment><USER10> FORTH ?KNOW IF HONK ELSE FORTH LEARN THEN

</comment></comment></comment></comment><comment><USER11> To this I would add synchronous programming[1], which is particularly suited for interactive or concurrent programs and formal reasoning, and has had success in industry in safety-critical realtime systems. Examples include Esterel[2] and SCADE, and outside realtime, Céu[3] and Eve[4] (the latter is based on Dedalus[5], which combines SP with logic programming).

As someone who loves formal methods and believes most mainstream software systems today are mostly interactive and/or synchronous, I think this paradigm has a lot of untapped potential, and I'm glad to see it slowly move out of safety-critical systems into the mainstream, in languages like Eve.

[1]: [https://en.wikipedia.org/wiki/Synchronous_programming_langua...](https://en.wikipedia.org/wiki/Synchronous_programming_language)

[2]: [https://en.wikipedia.org/wiki/Esterel](https://en.wikipedia.org/wiki/Esterel)

[3]: [http://www.ceu-lang.org/](http://www.ceu-lang.org/)

[4]: [http://witheve.com/](http://witheve.com/)

[5]: [https://www2.eecs.berkeley.edu/Pubs/TechRpts/2009/EECS-2009-...](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2009/EECS-2009-173.pdf)

<comment><USER12> Yeah, there are a lot of interesting benefits to synchronous programming that haven't been explored in a wider context and we're excited to be able to do so. Figuring out how to actually implement Eve's semantics has been quite a quest and unfortunately the implementations of most of those languages don't really fit us. Fortunately, we've put some really interesting things together lately that have produced some very surprising performance numbers for us, so hopefully that's finally resolved and we can move on to how GALS and the like apply in our world. :)

<comment><USER11> GALS is indeed the obvious next step. That's how I'd do it.

</comment></comment></comment><comment><USER13> ANI reminds me of HDLs [1] - I'm assuming that's the inspiration with terminology like "latch"?

Hardware is also concurrent by default. Coding some hardware logic will also change the way you approach coding. Anyone who's interested get an FPGA demo board and write some verilog or VHDL - I highly recommend it.

1\. [https://en.wikipedia.org/wiki/Hardware_description_language](https://en.wikipedia.org/wiki/Hardware_description_language)

<comment><USER14> Yes, I can't really understand why he didn't mention HDLs. I had never seen ANI before but both the syntax and terminology reminded me of VHDL.

<comment><USER15> These layers of abstraction seem to lead software bloggers to re-discovering concepts known by hardware engineers for decades.

</comment></comment></comment><comment><USER16> Honestly, I don't think that "concatenative" is a good term here. I prefer to call it a special case of combinator-oriented programming. You may see examples of this approach in vector languages like APL, FP and in functional world too (see Henderson's book, SICP and so on). The author of Joy (the language which spawned the whole "concatenative" activity) clearly was inspired by Backus's FP. Here we have stack combinators and we can emulate them even in Python, thanks to closures.

square = code(dup, op("*"))

Add a bit of syntactic sugar and you'll get "concatenative", or, better stack combinator-oriented language.

As for Prolog, I really appreciate that the author is calling it "declarative" not a "logic" language. It's more important to learn about backtracking and unification (powerful variant of pattern matching) than about something like Horn clauses. For anyone who wants to learn Prolog better (and it's worth it, Prolog is one of most beautiful PLs around!) I recommend this article: [http://www.amzi.com/articles/prolog_under_the_hood.htm](http://www.amzi.com/articles/prolog_under_the_hood.htm)

<comment><USER17> I disagree with your second point. "Logic programming" is a much more accurate term for programing with backtracking and unification than "declarative." For example Haskell is a very declarative language, but it doesn't use backtracking at all!

<comment><USER16> I prefer not to call it "logic programming" from the point of learning the language. Too many textbooks start from explaining that "Socrates is a man" or talk about Robinson's resolution. And, as a result, student doesn't know what to do with this language.

Declarative is a vague term, but for me it means mostly a way to compactly describe your problem in domain-specific terms. There are some languages in which you can produce compact code, like APL or J. But declarative for me means readable too. And there are cases, when in Prolog one can write a more compact and readable code than in Haskell. In Prolog you can describe just the essence of the problem. Not always, of course.

Another interesting thing about Prolog that it's a small language. It means that it has only few internal parts that make it alive (The complexity of many Prolog implementations is a result of fighting for perfomance). I really like small languages (like Oberon or Forth, for example), because it's possible to learn how they work internally. And the knowledge of this inner working helps to understand the language better. There is nothing "logical" inside Prolog, just a few powerful imperative constructs.

The author of "Prolog Under the Hood An Honest Look" says:

"Prolog, billed as "logic programming", is not really. You may be disappointed if that's what you expected to find. On the other hand, having backtracking, unification, and recursion inside one computer language leads to something very powerful and special."

And I, personally, like Prolog terms very much!

</comment></comment></comment><comment><USER18> Would like to mention _concept-oriented programming_ [1] which is work in progress but has highly ambitious goals of changing the way we think of programming. The initial idea is to make _references_ active and customized elements of the program which can intercept all accesses to the represented objects. A new programming construct, called _concept_ (hence the name of the approach), describes both behavior of references and behavior of objects. Objects exist in a hierarchy modeled by the concept hierarchy. IS-IN relation is used instead of the traditional IS-A. Also, concept-oriented programming distinguishes between incoming and outgoing methods, that is, every method has two versions: for external access and for internal access. More papers in [2].

[1] [https://arxiv.org/abs/1501.00720](https://arxiv.org/abs/1501.00720) [2] [https://www.researchgate.net/profile/Alexandr_Savinov](https://www.researchgate.net/profile/Alexandr_Savinov)

Disclaimer: I am the author of concept-oriented programming and data model

<comment><USER19> How does your research interact with object-capability models of computation, as in the E programming language?

<comment><USER18> (I can be wrong but) as far as I understand E is based on objects and messages as primary mechanisms, that is, we do not know where objects exist, how they are managed and how messages are transferred. Concept-oriented programming (COP) is a references-first approach while objects are defined as being _functions of references_ , that is, object is a derived (secondary) element of the model and the goal is to be able to have full control over this mechanism (custom heap, custom garbage collection, custom access control and security model etc.)

What I see similar in object-capability model and COP is that they both try to treat _object access_ as a highly important part of a system behavior. In COP, I used to write that it is more important what happens during access rather than in the object itself. Hence, being able to make these intermediate actions integral part of the program (and develop good PL for that purpose) is very important.

</comment></comment></comment><comment><USER20> Will Eve ever take off? I like the thoughts behind it.

[https://youtu.be/VZQoAKJPbh8](https://youtu.be/VZQoAKJPbh8) very good talk about the background of eve. When he finally talks about eve you might want to switch to a more recent talk about it.

<comment><USER12> Eve[1] is in the process of becoming a lot more real than it has been up to this point. We've found a great model and discovered a way to build a high performance implementation of it, which means much of the foundational research is finally in place. Over the next couple of weeks, we'll be revamping our website, docs, etc to help people get started building real things with it. :)

There's going to be a lot of really exciting stuff coming over the next few months. We've gathered a set of ideas, evidence, and implementations that have certainly blown us away - we hope others will find it valuable too.

EDIT: I realized I didn't address your initial question. Fwiw, we just recently crossed a really big milestone in terms of usage - more than 40,000 people have now played around with Eve on [http://play.witheve.com](http://play.witheve.com) and we've learned a ton from that experience. Part of the website revamp will be making that workflow simpler and nicer. We have a surprisingly high conversion rate (> 30%), so hopefully we can help smooth out that experience and begin to grow the community more and more.

[1]: [http://witheve.com](http://witheve.com)

<comment><USER21> I can't load the site on my phone. Mind pointing out what makes Eve so special? I'm suspicious of us figuring out anything mind boggling new at this point and assumed Eve was all a gimmick (I hope to be proved wrong :)). Something like Red makes a lot of sense to me as that ahhh language as it is tiny with no install, can be used for high/low level coding, has excellent DSLs such as GUI builders, and can compile to a native binary to name a few things that kind of shocked me. Eve seems to be more like an online Smalltalk? It's always fascinating to hear new ideas and I wish the best for your project!

<comment><USER22> We've certainly taken a lot of inspiration from Smalltalk, but I think the semantics we've arrived at make a really nice programming environment, with some surprising properties you may not think are possible.

Eve has a similar philosophy to Red/Rebol - that programming is needlessly complex, and by fixing the model we can make the whole ordeal a lot nicer. We start with a uniform data model - everything in Eve is represented by records (key value pairs attached to a unique ID). This keeps the language small, both implementation-wise and in terms of the number of operators you need to learn.

Programs in Eve are made up of small blocks of code that compose automatically. In each block you query records and then specify transforms on those records. Blocks are short and declarative, and are reactive to changes in data so you don't worry about callbacks, caching, routing, etc.

Due to this design, we've reduced the error footprint of the language -- there are really only 3 kinds of errors you'll ever encounter, and those mostly relate to data missing or being in the wrong shape that you expect. What's more, we'll actually be able to catch most errors with the right tooling. You'll never experience your app crashing or errors related to undefined/nil values.

We've made sure your program is transparent and inspectable. If you want to monitor a value in the system, you can just write a query that displays it, as the program is running. I like to think of this as a "multimeter for code". You can do this for variables, memory, HTTP requests, the code itself ... since everything is represented as records, everything is inspectable.

Because at its core Eve is a database, we also store all the information necessary to track the provenance of values. This is something most languages can't do, because the information just isn't there. So for instance if a value is wrong, you can find out exactly how it was generated.

There's a lot more work to do, but we have big plans going forward. We plan to make the runtime distributed and topology agnostic, so you can potentially write a program that scales to millions of users without having to worry about provisioning servers or worrying about how your code scales.

We're also planning on multiple interfaces to the runtime. Right now we have a text syntax, but there's no reason we couldn't plug in a UI specific editor that integrates with text code. We've explored something like this already.

Anyway, those are future directions, but what we have right now is a set of semantics that allow for the expression of programs without a lot of the boilerplate and hassle you have to go through in traditional languages, and which provide some unique properties you won't find in any other language (at least none that I've used).

<comment><USER23> Thank you for these intriguing thoughts behind the development of Eve. This project was for me the most valuable find in this whole discussion. There are a number of fundamental design decisions in Eve that opened my eyes to a fresh rethinking of the underlying assumptions in existing languages.

The code examples demonstrate surprising simplicity in achieving features that would be complicated to implement in other languages. I'm convinced that Eve will influence how programmers think (at least it did for me) and promote development of languages/frameworks/libraries that adopt some of these ideas. Great work, will be following with interest.

</comment></comment></comment></comment></comment><comment><USER24> Array oriented programming languages are also pretty interesting:

[https://en.wikipedia.org/wiki/APL_(programming_language)](https://en.wikipedia.org/wiki/APL_\(programming_language\))

[https://en.wikipedia.org/wiki/J_(programming_language)](https://en.wikipedia.org/wiki/J_\(programming_language\))

<comment><USER25> Especially in something like kdb.

<comment><USER21> I hear this a lot, but am confused in that I can't find hardly any examples anywhere. It'd be nice if kx systems put some videos of people querying data and building charts...etc.

<comment><USER25> [http://tech.marksblogg.com/billion-nyc-taxi- kdb.html](http://tech.marksblogg.com/billion-nyc-taxi-kdb.html)

<comment><USER21> A nice demo, but still doesn't show examples of a customer going through an example dataset and building dashboards. The kx site is good at talking about all their customers without giving a whole lot of real info. I wish they had a 64-bit hobbyist license.

<comment><USER25> I don't know about 64-bit but people in prior HN discussions said you can download a free one off their web site. You should be able to extrapolate some things from that.

EDIT: [https://kx.com/download/](https://kx.com/download/)

<comment><USER21> True, and thank you. I think it'd be nice if they had a video of a user on a sample system running queries and building displays. Yea I can play with the demo, but for that price I'd expect some promotional materials to be made.

</comment></comment></comment></comment></comment></comment></comment><comment><USER26> A few random comments:

Forth is a great concatenative language, since its the pioneer in that area (I think), but Factor is definitely worth mentioning too as a "modern" take on the paradigm. It essentially tries to be a concatenative Lisp.

ANI was dead even in 2014 when this article was written (which the author acknowledges: _" the language seems dead, but the concepts are pretty interesting"_). It has some really interesting ideas, but since it never got implemented, I'm not sure how much use there is in discussing it here amongst _real_ languages. It would be useful as a discussion for possible future languages for sure, but its currently still just a concept, so I'm not sure what _practical_ thing you can learn from it right now.

</comment><comment><USER27> For some extra dependently typed fun, check out ATS and Dafny.

ATS is aimed at system programming, and if you think Idris has a steep learning curve, you'll need belaying for ATS. And, the language is horrible. But it's really mind expanding to see it in action.

Dafny is a really basic language with support for Hoare/Dijkstra verification. It's completely unlike the type system model.

</comment><comment><USER28> ANI/Plaid reminded me of the LabVIEW visual dataflow language, which is quite widely used in the branch of physics I used to work in, for data acquisition and instrument control. While I've often longed for a text-based alternative that plays better with modern version control and my favorite text editors, I have to say that having everything laid out for you in a visual way does make it easier to reason about the execution flow. That is, after a few years of working with it --- initially, this paradigm shift was rather a painful stretch of the nerves.

If every language has its own specific dark patterns and bottlenecks, LabVIEW's is definitely the "brightly-colored spaghetti" structural breakdown of an advanced beginner's code :-)

Incidentally, why do we, as programmers, tend to focus on a language's bottlenecks so much, in such an emotionally charged way? Any psychology-of- programming people out here? You might consider LabVIEW an excellent case study in getting on people's nerves...

</comment><comment><USER29> I'd recommend to everybody (but especially those involved in either embedded systems or a lot of concurrent state) to try out HSM / state chart programming (note: this has basically nothing to do with "flat" FSMs). It's as close to a silver bullet as you'll ever get for these kinds of systems.

Stateflow or QP/QM, all other systems suck.

<comment><USER30> Is it useful in writing drivers ? or mostly for application code ?

And what are the drawbacks? Why aren't everybody using it?

<comment><USER29> It's used heavily in application code for automotive ECUs. It has code generators that generate output with a really, really, small footprint and zero runtime overhead; due to optimization at very high levels, this is on the level of really good LTO optimization.

Drawbacks: it's very un-agile; you really have to think the system through completely. (The magic being that if you do this, it is very likely correct by design.) It's not really feasible to specify a part of the system now and leave other parts open for later refinement. The other drawback being that no good non-commercial options exist.

<comment><USER30> >> It's not really feasible to specify a part of the system now and leave other parts open for later refinement.

Is there any work or ideas on how to solve that issue?

And so it's also hard to add features later, in next versions ?

<comment><USER25> Stuff like these. It overlaps with model-driven development where you work at a higher level in constrained way to knock out many issues. Then, it generates safe code from that which you also check with tests or other tools.

[https://en.wikipedia.org/wiki/Stateflow](https://en.wikipedia.org/wiki/Stateflow)

[https://en.wikipedia.org/wiki/Simulink](https://en.wikipedia.org/wiki/Simulink)

Recent example from high-assurance security:

[https://www.umsec.umn.edu/sites/www.umsec.umn.edu/files/hard...](https://www.umsec.umn.edu/sites/www.umsec.umn.edu/files/hardin- icfem09-proof.pdf)

</comment></comment></comment></comment></comment><comment><USER23> Thought-provoking. The examples are all programming languages, but the paradigms themselves can apply on a smaller scale, i.e., for application features, as design patterns or inspiration.

The section on "symbolic programming" has me pondering still about potential implications. It makes me imagine something like a "visual" WYSIWYG editor, but a "conceptual" editor.. Looking forward to digging deeper via provided references.

</comment><comment><USER31> It's strange to see ANI mentioned as if it were a real, working language. AFAIK it was never able to compile even the samples: [https://code.google.com/archive/p/anic/issues/7](https://code.google.com/archive/p/anic/issues/7)

</comment><comment><USER32> Wait. What exactly is esoteric about these paradigms? All the books I've read simply call them regular paradigms.

<comment><USER21> You're correct that I'd not consider these esoteric, just not procedural or OO. Esoteric would be something like Brainf __*, the music programming language, or that art language (forget the name). Unusual but still commercial and useful paradigms are logic, array, functional, and concatenative to name a few.

<comment><USER33> Piet. The Mondrian language I'm guessing

<comment><USER21> Yes that was it.

</comment></comment></comment></comment><comment><USER34> Curious. ANI seems to me like an abstract form of graph-parallel programming, where the language itself is the scheduler.

There are some production-ready schedulers for GPP, like Intel's TBB[1] (C++), but learning to be effective with this requires a major shift in thinking about code - essentially thinking in graphs.

[1] - [https://www.threadingbuildingblocks.org/tutorial-intel- tbb-f...](https://www.threadingbuildingblocks.org/tutorial-intel-tbb-flow- graph)

<comment><USER35> My team has been working on a Python library called Loman that represents computations as graphs. We've open-sourced it [1][2]. One of our aims is to make it as natural as possible to use graph-based programming, and within an already-familiar programming language. Be interested to know what you think.

[1] [https://github.com/janusassetallocation/loman](https://github.com/janusassetallocation/loman) [2] [http://loman.readthedocs.io/en/latest/user/intro.html](http://loman.readthedocs.io/en/latest/user/intro.html)

<comment><USER34> Can you demo your library with a more complex example, e.g. the Dining Philosophers Problem. Here[1] is the solution using TBB, and here[2] a more recent version - using a multioutput function node to optimize the flow.

[1] - [https://software.intel.com/en-us/blogs/2011/01/10/using- the-...](https://software.intel.com/en-us/blogs/2011/01/10/using-the-intel- threading-building-blocks-graph-community-preview-feature-an-implementation- of-dining-philosophers)

[2] - [https://software.intel.com/en-us/blogs/2011/09/13/using- inte...](https://software.intel.com/en-us/blogs/2011/09/13/using-intel- tbb-40-features-to-simplify-dining-philosophers)

<comment><USER35> Thanks for the links. I took a look, and I think that the intention is quite different between the libraries. Our library would not directly apply to the Dining Philosophers Problem. Both libraries use graphs to represent dependencies between tasks, but they do so for different reasons, and to cover different uses. The Intel library does it with the intention of scheduling a given workload. Our library uses a directed acyclic graph to track state as either the data or function for given nodes of the graph are exogenously updated, either interactively during research, or from new incoming data in a real-time system. We cover where we think our library is useful in more depth in the introduction section of our documentation[1].

[1] [http://loman.readthedocs.io/en/latest/user/intro.html](http://loman.readthedocs.io/en/latest/user/intro.html)

</comment></comment></comment></comment><comment><USER36> Agent oriented-programming [http://robotics.stanford.edu/~shoham/www%20papers/AgentOrien...](http://robotics.stanford.edu/~shoham/www%20papers/AgentOrientedProgrammingAIJ.pdf) [PDF]

<comment><USER37> Alan Kay talking about agent-oriented computing in 1990:

[https://youtu.be/275FQ9koAw8?t=7647](https://youtu.be/275FQ9koAw8?t=7647)

Very interesting view, especially considering how long ago that was and how relevant they still are.

<comment><USER38> Some time after Java first came out, there was a product called Voyager from a Java products company called Objectspace [1]. Voyager was a product for creating and using mobile agents. I had downloaded the trial and tried it out a bit. It was quite cool. IIRC, Graham Glass, who was involved in ObjectSpace, was also the creator of Electric XML, an XML library, and was later CTO of WebObjects. Recently he had/has been working on EDU 2.0 (EDU20.org), an e-learning product company.

[1] They were also the creators of JGL, the Java Generics Library, which was like a Java version of the C++ STL, and done before Java got generics natively.

</comment></comment></comment><comment><USER39>
      > Dependent types
      >
      > Example languages: Idris, Agda, Coq
      >
      > You're probably used to type systems in languages like C and Java,
      > where the compiler can check that a variable is an integer, list, or string.
      > But what if your compiler could check that a variable is "a positive integer",
      > "a list of length 2", or "a string that is a palindrome"?

This is what I love about SQL. You can even define your own types, like "email", at least in PostgreSQL:

      create table contacts (
        name text not null,
        age int check (age >= 0),
        email email
      );

It already has a few of these special types built in, like for IP and MAC addresses ([https://www.postgresql.org/docs/current/static/datatype.html](https://www.postgresql.org/docs/current/static/datatype.html)).

<comment><USER40> Out of interest, how is common ORM support for custom Postgres types?

<comment><USER41> GeoAlchemy for PostGIS/SQLAlchemy is a good example of explicit support. But typically, you can always "deal" with custom types in your ORM, even if that means falling back to binary data.

</comment></comment></comment><comment><USER42> Shame not to see factor in the concatenative list, it addresses some of the pain points there with locals

<comment><USER36> Postscript would also have been a fine addition and has its own methods of dealing with locals. [https://www.adobe.com/products/postscript/pdfs/PLRM.pdf](https://www.adobe.com/products/postscript/pdfs/PLRM.pdf) [PDF]

<comment><USER10> What a sad world we live in when Adobe publishes a paper about PostScript in PDF (which is just PostScript without the programming language).

To help offset the irony and celebrate Turing completeness, here is a PostScript interpreter implemented in PostScript, and an explanation of why.

[http://www.donhopkins.com/home/archive/cyber/litecyber/ps.ps...](http://www.donhopkins.com/home/archive/cyber/litecyber/ps.ps.txt)

[http://www.donhopkins.com/home/archive/cyber/litecyber/ps.ps...](http://www.donhopkins.com/home/archive/cyber/litecyber/ps.ps.reasons)

[http://www.donhopkins.com/drupal/node/97](http://www.donhopkins.com/drupal/node/97)

</comment></comment></comment><comment><USER43> I have also seen _persistent by default_ where every variable is by default store in a database and automatically initialized when you come back to that piece of code. Useful for web development. (Sorry, forgot the name of the programming language)

<comment><USER23> I'd agree that "persistent by default" is an unusual and interesting approach, that would be suitable for the list of paradigms that may "change the way you code".

It reminds me of a statement I read about managing application state, to treat the state (in this case a Redux store) as an "in-memory database". Add a layer to load/persist automatically - via LocalStorage, WebSocket, etc. - and it would be persistent by default. I suppose you wouldn't want _everything_ persistent though, just a relevant slice of state.

Here's an article about "persistent languages", which includes discussion on related features. [http://wiki.c2.com/?PersistentLanguage](http://wiki.c2.com/?PersistentLanguage)

</comment></comment><comment><USER44> This classification of "paradigms" is a bit off.

First, declarative programming is a generic name which includes a broad range of paradigms - from functional to logic programming. Logic programming is something that deserves a special mention and discussion, because there are a number of interesting and unique concepts that deserve a more in-depth explanation.

Second, "dependent types" is better understood as a feature of a language (or better yet, of a type system) than a paradigm by itself.

Some of the other "paradigms" also seem more like characteristics of languages, and not really something that structures the way solutions are expressed/understood.

<comment><USER45> This. There are three (and arguably only three) common programming paradigms: imperative programming, functional programming, and logic programming with lineages back to Turing machines, lambda calculus, and formal logic / proof search, respectively. Languages can be broken down along other dimensions, but usually the term "paradigm" is reserved for the sort of irreducible foundation of a language, and these seem to be the three useful ones.

Edit: to put a slightly finer point on it, this irreducible foundation mostly has to do with how the language "computes." Imperative languages compute via statements that modify program state. Functional languages compute via proof reduction to normal form. Logic languages compute via proof search.

<comment><USER46> There's no reason why you couldn't integrate functional programming and imperative programming into a single language – for example, an imperative layer (for I/O) around a functional, lambda-calculus based core (for computations). Now what is the _" irreducible foundation of [this] language"_?

</comment></comment></comment><comment><USER47> There should be a category for analogy based languages. Rail or the Billiard Ball Machine, which looks like Feynman diagrams on a pool table, are examples of this.

[https://esolangs.org/wiki/Rail](https://esolangs.org/wiki/Rail) [https://esolangs.org/wiki/Billiard_ball_machine](https://esolangs.org/wiki/Billiard_ball_machine)

</comment><comment><USER48> I'm kind of uncomfortable calling "declarative" a paradigm; it's a broad (and not binary) feature. Prolog and SQL are, respectively, the leading examplars of the logic and relational paradigms. They are both fairly declarative (but then, in the age of optimizing compilers, even C is somewhat declarative: your code constrains the result but it doesn't dictate the how as much as it seems to.)

</comment><comment><USER49> I would add pictorial programming languages, such as ProGraph if you want a really unusual way to program. Object oriented, but inherently dataflow. Loops were very weird though.

[https://en.wikipedia.org/wiki/Prograph](https://en.wikipedia.org/wiki/Prograph)

</comment><comment><USER50> ParaSail[0] is another implicitly parallel language. It has similar goals to Rust and Spark Ada.

[0] [https://forge.open-do.org/plugins/moinmoin/parasail/](https://forge.open- do.org/plugins/moinmoin/parasail/)

</comment><comment><USER51> On concatenative languages, I would like to add Piet[1] as a contender. Plus Piet program could look like 8-bit art (to me).

[1] [http://www.dangermouse.net/esoteric/piet.html](http://www.dangermouse.net/esoteric/piet.html)

<comment><USER51> I once read about Pieter Hintjens' model oriented programming [1] which the idea I have yet to understand. Hope someone can provide more insight on this subject. HN discussion [2]

[1] [https://github.com/imatix/gsl](https://github.com/imatix/gsl) [2] [https://news.ycombinator.com/item?id=11558007](https://news.ycombinator.com/item?id=11558007)

</comment></comment><comment><USER52> Re: "Dependent Types"

In Python, PyContracts supports runtime type-checking and value constraints/assertions (as @contract decorators, annotations, and docstrings).

[https://andreacensi.github.io/contracts/](https://andreacensi.github.io/contracts/)

Unfortunately, there's yet no unifying syntax between PyContracts and the newer python type annotations which MyPy checks at compile-type.

[https://github.com/python/typeshed](https://github.com/python/typeshed)

What does it mean for types to be "a first class member of" a programming language?

</comment><comment><USER53> Concurrency by default feels a bit like the underlying processor of the machine, what with superscalar architectures and all.

<comment><USER15> Hardware Description Languages tend to be concurrent by default, with specific syntax for sequential logic.

A parallel pair of AND gates is physically concurrent, let alone anything with a clock.

</comment></comment><comment><USER54> Great thought provoking article. Good explanation of Dependent Types, Title is misleading though, should be called - Particular or Specfic Types. Postgres has the same capability - Domains - always surprised that other db's such as sql server have never adopted this useful feature.

</comment><comment><USER55> There seems to be and old discussion over here [https://news.ycombinator.com/item?id=7565153](https://news.ycombinator.com/item?id=7565153)

</comment><comment><USER56> Aurora looks interesting, but it seems to be .Net/windows only?

<comment><USER12> That must be a different Aurora. The one mentioned here was never really released, only demo'd at Strange Loop. We subsequently went on to turn that into Eve[1].

[1]: [http://witheve.com](http://witheve.com)

<comment><USER57> Thanks for confirming that. This looks very interesting. How active is development of the mathematical side of things? Also have graphics capabilities been developed yet or are they far away? The HN article indicated Aurora now Eve would have these capabilities. I'm interested because of the similarities I see between Eve and other literate programming approaches such as the Jupyter project, Mathematica, Sage notebooks, R motebooks. Eve looks like it will soon be joining that group.

<comment><USER22> Recent development has been focused on shoring up the semantics of the language, making the runtime more performant, and packaging our syntax and editor to make it more usable for a wider audience (i.e. people outside our office). Efforts relating to a UI that is approachable from a non-programmer perspective have been waylaid until we produce something that is usable and comfortable for at least the programmer crowd.

</comment></comment></comment></comment><comment><USER10> I recently submitted a link about "Robust First Computing". It didn't get any response, but I'll repeat the link and description here, since it's certainly esoteric, but has some extremely important properties.

Robust-First Computing: Distributed City Generation [https://www.youtube.com/watch?v=XkSXERxucPc](https://www.youtube.com/watch?v=XkSXERxucPc)

A Movable Feast Machine [1] is a "Robust First" asynchronous distributed fault tolerant cellular-automata-like computer architecture.

The video "Distributed City Generation" [2] demonstrates how you can program a set of Movable Feast Machine rules that build a self-healing city that fills all available space with urban sprawl, and even repairs itself after disasters!

The paper "Local Routing in a new Indefinitely Scalable Architecture" [2] by Trent Small explains how those rules work, how the city streets adaptively learn how to route the cars to nearby buildings they desire to find, and illustrated the advantages of "Robust First" computing:

Abstract: Local routing is a problem which most of us face on a daily basis as we move around the cities we live in. This study proposes several routing methods based on road signs in a procedurally generated city which does not assume knowledge of global city structure and shows its overall efficiency in a variety of dense city environments. We show that techniques such as Intersection-Canalization allow for this method to be feasible for routing information arbitrarily on an architecture with limited resources.

This talk "Robust-first computing: Demon Horde Sort" [4] by Dave Ackley describes an inherently robust sorting machine, like "sorting gas", implemented with the open source Movable Feast Machine simulator, available on github [5].

A Movable Feast Machine is similar in many ways to traditional cellular automata, except for a few important differences that are necessary for infinitely scalable, robust first computing.

First, the rules are applied to cells in random order, instead of all at once sequentially (which requires double buffering). Many rule application events may execute in parallel, as long as their "light cones" or cells visible to the executing rules do not overlap.

Second, the "light cone" of a rules, aka the "neighborhood" in cellular automata terms, is larger than typical cellular automata, so the rule can see other cells several steps away.

Third, the rules have write access to all of the cells in the light cone, not just the one in the center like cellular automata rules. So they can swap cells around to enable mobile machines, which is quite difficult in cellular automata rules like John von Neumann's classic 29 state CA. [6] [7]

Forth, diffusion is built in. A rule may move the particle to another empty cell, or swap it with another particle in a different cell. And most rules automatically move the particle into a randomly chosen adjacent cell, by default. So the particles behave like gas moving with brownian motion, unless biased by "smart" rules like Maxwell's Demon, like the "sorting gas" described in the Demon Hoard Sort video.

In this video "Robust-first computing: Announcing ULAM at ECAL 2015" [8], David Ackley explains why "Robust First" computing and computing architectures like Movable Feast Machines are so incredibly important for scaling up incredibly parallel hardware.

I think this is incredibly important stuff in the long term, because we've hit the wall with determinism, and the demos are so mind blowing and visually breathtaking, that I want to try programming some of my own Movable Feast Machine systems!

[1] [http://movablefeastmachine.org/](http://movablefeastmachine.org/)

[2] [https://www.youtube.com/watch?v=XkSXERxucPc](https://www.youtube.com/watch?v=XkSXERxucPc)

[3] [http://www.cs.unm.edu/~ackley/papers/paper_tsmall1_11_24.pdf](http://www.cs.unm.edu/~ackley/papers/paper_tsmall1_11_24.pdf)

[4] [https://www.youtube.com/watch?v=helScS3coAE](https://www.youtube.com/watch?v=helScS3coAE)

[5] [https://github.com/DaveAckley/MFM](https://github.com/DaveAckley/MFM)

[6] [https://en.wikipedia.org/wiki/Von_Neumann_cellular_automaton](https://en.wikipedia.org/wiki/Von_Neumann_cellular_automaton)

[7] [https://en.wikipedia.org/wiki/Von_Neumann_universal_construc...](https://en.wikipedia.org/wiki/Von_Neumann_universal_constructor)

[8] [https://www.youtube.com/watch?v=aR7o8GPgSLk](https://www.youtube.com/watch?v=aR7o8GPgSLk)

</comment><comment><USER58> Isn't Lua supposed to be an example of a concatenative language?

<comment><USER59> Not at all.

The definition I like to use of concatenative language is:

If "X Y" is a legal program, then "X" is a list of tokens and a legal program and "Y" is a list of tokens and a legal program, and semantically, executing "X Y" is equivalent to executing "X" and then executing "Y".

practical implementations often deviate a little from this ideal.

<comment><USER58> Not sure where I had it from, probably some other language and I got it mixed up with Lua in my head.

</comment></comment></comment><comment><USER60> I believe HN title convention is to remove the number of list items ex. this title should be just "Programming paradigms that will change how you think about coding".

<comment><USER61> You're right, and "... that will change how you think about coding" is clickbait. Luckily the article contains an adjective for that, which we've used in the title. Thanks!

<comment><USER62> I realise moderation is tough an never pleases everyone, but have to say I'm disappointed here: in some circles, "esoteric" carries some quite strong negative connotations, which I think are unwarranted here.

Some of these languages are definitely suitable for "serious" usage. And I'm not sure I'd count SQL (or Prolog, for that matter) as esoteric at all!

<comment><USER61> That's a good point. We'll happily update the title again if someone can suggest a better one still using the author's language.

<comment><USER63> The suggestion from 'pitaj' that started this comment thread was perfect.</comment></comment></comment></comment></comment>


Techcrunchywag - <AUTHOR> http://mattmaroon.com/?p=536 <comment><USER2> Just curious, being a Valley outsider (Washingtonian): How common is the startup that finds the middle ground between working to the bone (trying desperately to be the next Google/Yahoo/Microsoft and secure massive VC) and the expect-nothing-back, RMS-enamored open source group?

Because that's where I'd like to be: A tech shop that cares about turning a profit, but that's equally concerned with innovation and just having a good time. It seems to me that many people affiliated with the startup scene are way too dollar-driven or take themselves too seriously.

<comment><USER3> So, I know you're asking more from an "approach to business" perspective than a "how much Open Source goes on in the valley" perspective...but, I figured I'd chime in, anyway:

I've been surprised by how little Open Source happens in the valley, at least among the "young, rich and good looking" startup set that shows up all the time on TC and Valleywag. I'm somewhat disappointed by it, as well. Folks are building everything they do on Free and Open Source Software. It's polite to give something back, even if the license was written before web apps were a presence, and so you aren't legally obligated to do so. I don't want that to sound _too_ harsh or too inclusive. There are tons of startups, in the valley and elsewhere, that _do_ take part in Open Source development, but I'd say for every one that I meet at events, I meet five startup founders that have never contributed a line of code to Open Source, even though their apps are built with PHP, Ruby, Perl, or Python, using vast swaths of Open Source library code, are checked into git or Subversion, and run on top of Linux. This could just be selection bias, since it seems like a lot of OSS folks are more likely to be bootstrapping outside of the valley.

Anyway, we're an Open Source project (Webmin/Virtualmin/Usermin) turned startup. It has positives and negatives, but I don't think one can say, "You can't be the next Google/Yahoo/Microsoft, if you're running a fun Open Source oriented company"...we don't know that yet. It's still early in the history of OSS startups. Red Hat does OK. MySQL AB sold to Sun for ~$500 million, XenSource to Citrix for ~$300...Not Google/Yahoo/MS money, but nothing to sneeze at. Making money on Open Source is harder than on proprietary software, in general. But, you get some awesome benefits. Like, how many of our competitors can claim _millions_ of users? Not a single one. While our software has been downloaded over 12 million times from a single source (and OSS ends up in all sorts of funny places without showing up on the download counter, because it gets packaged, included with distros and hardware products, comes from local mirrors, etc.). And, let's face it, when you have a million people looking at your software on a daily basis, you pretty much can't help but make money if you're trying. Free is a powerful game changer in most markets, and changing the game might be mandatory if you're working in an established market against strong competitors.

From the perspective of raising money, investors don't have a problem with it, and most understand OSS. It may even be a positive angle for them, assuming you still have a business model after factoring in, "But it's free!"

<comment><USER4> > I've been surprised by how little Open Source happens in the valley,

I'm not. I lived there during the last boom, and worked at an open source company, Linuxcare. Pretty much anyone who was anyone at that company in terms of actual open source contributions came from elsewhere (well, there were a few exceptions, but not many). Our strongest teams were in Australia, Canada and Italy.

I think the reason is fairly straightforward: the valley is expensive, and there are lots of startups going on. There is less of a "tinkering with something just for the pure pleasure/heck of it" spirit. Maybe that goes on too, but the next thought is "huh, this _is_ pretty cool, I wonder how I can monetize it?". It's also easy to get hired doing reasonably interesting stuff, leading to less time on your own experimenting, and larger opportunity costs for those who don't pursue a job.

</comment></comment></comment><comment><USER5> Despite what a couple bloggers might say, I don't think anyone is actually _angry_ at "Team Cyprus" for having a vacation. More so, it is a feeling of jealousy/admiration that they were able to enjoy themselves at a time when many of us are in state of worry and fear.

Calling it the end of web 2.0 might be too much, but you have to appreciate the juxtaposition in some of the most beautiful and successful people in the valley partying on an island paradise while the world that made them so successful is crashing down.

<comment><USER6> But that's the thing, nothing in the valley came "crashing down" except maybe the net worth of some investors, who just went from obscenely wealthy to very wealthy. And maybe TechCrunch's standards.

Buildings are all still standing. Almost every company that was in business yesterday is still in business today. There've been a few layoffs, but those were due to issues stemming a while back.

Everything is, for the most part, the way it was two weeks ago. It'd be one thing if there was an 8.2 Earthquake. But the Dow dropping?

<comment><USER7> Matt, I'm worried about you. I don't think your level of alarm is sufficient. When those buildings do start falling over, you won't be prepared! It basically goes Dow drop -> Earthquake -> Zombies. Those of us who realize that are just trying really hard to help our fellow Americans by posting article after unsubstantiated article with our thoughts on how exactly the world is about to end. Stop undermining this important public service, sir!

<comment><USER6> Wow, I hadn't thought about Zombies. Thanks.

<comment><USER7> No prob. Just remember, shoot them in the head, okay? Otherwise, you'll just embarrass yourself. After careful _analysis_ of various _sciences_ I have determined we have 17-19.5 days to prepare for Zombie Judgement Day. Don't fuck this up.

<comment><USER6> Hmm, with the Brady Bill and all that, I'm not sure I can get a shotgun in that amount of time. There really should be laws allowing for looser gun control whenever Zombies are a near-term possibility.

<comment><USER7> I agree, but nobody ever said life would be easy. Baseball bats, golf clubs, these things work in the meantime. I mean, sooner or later your neighbor with a shotgun is going to get his face eaten, at which point you can grab his. Pistols work too (.45 or high caliber recommended) in the short term.

<comment><USER8> What's wrong with a good old fashioned stake through the heart? I know commodities are falling, but fuck, lead is still pricey!

<comment><USER7> _sigh_ amateurs! We're talking Zombies here, not Vampires. Vampire Judgement Day isn't for another 287 days.

<comment><USER6> Plus I'm far too lazy to go around trying to trap them so as they cannot eat my brain while I experiment with stakes. I require a projectile for Zombie killing, otherwise I might as well just give up and join them.

<comment><USER7> Do that and the terrorists win. The zombie terrorists.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER9> I agree, the content on techcrunch continues to tend towards random wild opinion instead of tech startup coverage. From Arrington's summer of hate for twitter, to the current sky is falling, its becoming impossible to stay interested.

<comment><USER10> It's in danger of coming out of my Google Reader, I've already got plenty of other sources for startup and tech news in there and I'd rather read the personal blogs of people with interesting opinions than the mass-produced tripe being churned out by TechCrunch at present. TC is wearing out my "J" button and I can't afford another. There's a credit crunch on, you know.

<comment><AUTHOR> I actually just removed it from my Google Reader a few hours ago. Got sick of filtering out all the noise and figured all the good stuff will float to the front page of HN anyways.

<comment><USER11> Oh like this story you mean? Thanks for bringing this to HN btw.

</comment></comment></comment></comment><comment><USER12> _"least get a heads-up on a Turkish vacation"_

I'd like you to correct that. Cyprus is GREEK! It has been for the past 3000 years.

Welcome to my home country.

<comment><USER13> Isn't Cyprus the most heavily militarized land in the world, being contested by the turks, greeks, and locals? <http://en.wikipedia.org/wiki/Cyprus>

"The island is de facto partitioned into four main parts:[4]

        * the area under the effective control of the Republic of Cyprus, in the south of the island;
        * the Turkish-occupied area in the north,[5] calling itself the Turkish Republic of Northern Cyprus (recognized only by Turkey);
        * the United Nations-controlled Green Line, separating the two; and
        * two British Sovereign Base Areas (Akrotiri and Dhekelia).[6]"

<comment><USER12> Unfortunately, like you said the 37% is occupied since the 1974 invasion. Greek-Cypriots were raped and forced out of their homes and their land and they are 80% of the population.

Cyprus won its independece in 1960 from the British (who have been on the island since late 18th century).

The Turks came to the island for the first time on 15th century.

The history of the island is totally Greek so if someone is going to refer to the island then at least should do it correctly cause otherwise is only doing propaganda and helping the wrong information to be known.

Attempts are made that the political situation is resolved but I am not very optimistic.

<comment><USER6> Well, if the part they were vacationing in is technically Turkish, then it was a Turkish vacation. That's what I read somewhere, though I have no idea if it is true.

<comment><USER12> So because there are 34 million Spanish speakers in US I am going to say US is Spanish?

There are 3 million Greeks in United States but If I come to US I suppose I'd say I am going to Greece?

The only excuse to call it a turkish party is if there was a Turk amongst them. Otherwise is wrong and irritating.

Otherwise, the only reasonable way to refer to it, so not to provoke, is call it a Cyprus party.

</comment></comment></comment></comment></comment><comment><USER14> How do people feel about banning Techcrunch for a week on an experiment basis? Afterwards - Vote. This is what happens when dollar signs get in the way of building something fucking cool or useful.

 _Complete speculation_ , but I feel that newer people tend to vote up Techcrunch articles (regardless of topic) because they've heard of it before.

<comment><USER15> I think we should stop banning sites as a solution to moderation.

All this TC backlash is getting somewhat ridiculous but at the same time it is what it is. There's plenty of tech news sites out there but they all report on the same news because they all read the same feeds and have access to the same scoops. The only way to differentiate is to editorialize the news. It's much the same as 24 hour cable news.

But choosing to write 746 word blog posts or pounding TC with all these comments or upvoting these things to #1 is the real problem HN has. I really wish people would just let these minor things go.

Stop upvoting LAME stories. Stop upvoting whiney blog posts ABOUT lame stories. A bit of self control is a lot more powerful than censoring websites.

<comment><USER11> Too bad the karma leader-board/system doesn't really encourage self-control. Not that I'm in favor of banning anything, but I do think something is clearly not working when this is the top-story on HN.

<comment><USER15> What if we do away with the leaderboard?

</comment></comment></comment></comment><comment><USER16> I like Matt's blog, he brings a much needed bit of realism to places like HN without going into Uncov's over-the-top contrarianism.</comment>


Twitter Tracking Outbound Link Clicks - <AUTHOR> http://ekstreme.com/thingsofsorts/seosem/twitter-tracking-outbound-link-clicks <comment><USER2> Maybe there is some monetization plan in the works that would use that data

</comment><comment><USER3> Only on the web site, I suppose?</comment>


Update your iPhone Your iPhone can get hacked just by opening JPEG image - <AUTHOR> https://www.facebook.com/AndroidMalware/photos/a.899684773388358.1073741828.898235870199915/1232437960113036/?type=3&theater <comment><USER2> Please submit the primary source of the news, in this case [http://thehackernews.com/2016/10/how-to-hack- iphone.html](http://thehackernews.com/2016/10/how-to-hack-iphone.html), not a facebook photo. I'm writing this because all 9 of your submissions so far have been facebook photos.</comment>


The Hyperledger Project - <AUTHOR> https://www.hyperledger.org/ <comment><USER2> How is it related to this? [https://news.ycombinator.com/item?id=8009663](https://news.ycombinator.com/item?id=8009663)

<comment><USER3> The name was donated by the company that bought Hyperledger last year, and one of the codebases being donated also descends from the original Hyperledger codebase.

<comment><USER2> So after all there is code somewhere! [https://github.com/hyperledger/hyperledger/issues/1](https://github.com/hyperledger/hyperledger/issues/1)

</comment></comment></comment><comment><USER4> Can someone give me a decent explanation of how blockchain will speed up a securities settlement?

E.g: Big Bank sells 200m of some bond to a hedge fund. Bond is actually "given up" to a third party who hold bond on HF's behalf. Appreciate there's a whole load of operational shenanigans that go into making this happen. Just not sure what, or how blockchains will help.

<comment><USER5> There are usually several systems involved in a settlement, all run by different parties - the bank (broker), the custodian (which holds the certificate) and the counterparties that are trading. They all have representations of the same trade that are mostly out-of-sync, and reconciling these systems incurs delays.

With the blockchain, none of these parties need necessarily trust each other, but all can share the same system which shows the current state of the transaction. All parties can observe a ledger that is distributed in real time. So they don't need any reconciliation steps anymore and all trades are "T0" (same day) settled

</comment></comment><comment><USER6> has anyone seen this deprecated project floating around? [https://github.com/danoprey/depreciated](https://github.com/danoprey/depreciated) seems like actual elixir code that must have been bought by [http://www.digitalasset.com/](http://www.digitalasset.com/)

I've been watching this for a bit

<comment><USER7> It's not the Hyperledger TFA is about. (Confusing, I know, because DAH is a participant of the Linux Foundation Hyperledger project.)

</comment></comment><comment><USER8> Mission of Hyperledger Project ("HLP").

The mission of HLP is to:

a. create an enterprise grade, open source distributed ledger framework and code base, upon which users can build and run robust, industry-specific applications, platforms and hardware systems to support business transactions.

b. create an open source, technical community to benefit the ecosystem of HLP solution providers and users, focused on blockchain and shared ledger use cases that will work across a variety of industry solutions;

c. promote participation of leading members of the ecosystem, including developers, service and solution providers and end users; and

d. host the infrastructure for HLP, establishing a neutral home for community infrastructure, meetings, events and collaborative discussions and providing structure around the business and technical governance of HLP.

...

Governance

HLP shall be composed of Premier, General and Associate Members. All Premier and General Members must be current corporate members of The Linux Foundation (at any level) to participate in HLP as a member. Anyone may propose a contribution to HLP's technical codebase regardless of membership status. All participants in HLP, including Associate Members, enjoy the privileges and undertake the obligations described in this Hyperledger Project Charter, as from time to time amended by the Governing Board with the approval of The Linux Foundation ("LF"). During the term of their membership, all members will comply with all such policies as the LF Board of Directors and/or the HLP may from time to time adopt with notice to members.

...

Licensing

a. Members agree that all new inbound code contributions to HLP shall be made under the Apache License, Version 2.0 (available at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)). All contributions shall be accompanied by a Developer Certificate of Origin sign-off ([http://developercertificate.org](http://developercertificate.org)) that is submitted through a Governing Board and LF-approved contribution process. Such contribution process will include steps to also bind non-Member Contributors and, if not self-employed, their employer, to the licenses expressly granted in the Apache License, Version 2.0 with respect to such contribution.

b. All outbound code will be made available under the Apache License, Version 2.0.

...

I found the copy on the landing page to be too fancy and ornate to be useful. From a brief glance, it seems that they want to tie as many businesses together as possible into one private blockchain-based network in order to make payment verification and settlement quicker/more secure. Banks are already looking into this and exploring their own private blockchain network. [1]

This means that all payments to and from companies within the hyperledger network will be recorded and made known to all other participants in the network. If it works they will move on to transparently recording production logs, which will ostensibly help in keeping producers honest about their manufacturing process and help drive down error tolerance.

Two main problems I see immediately:

1\. Tiered supply chains are so complex that it will require a _huge_ onboarding effort to get enough companies on the ledger to make it useful to any one company.

2\. Companies, much like individuals, love privacy! I'm assuming the protocol will include some type of identity-cloaking cryptographical overhead that will increase latency/complexity and reduce the benefit of having an open ledger.

Still, a really cool idea and application of blockchain tech that will be a great experiment of building a massive, ambitious network from scratch.

[1] [http://www.wired.com/2015/12/big-tech-joins-big-banks-to- cre...](http://www.wired.com/2015/12/big-tech-joins-big-banks-to-create- alternative-to-bitcoins-blockchain/)

<comment><USER9> >From a brief glance, it seems that they want to tie as many businesses together as possible into one private blockchain-based network in order to make payment verification and settlement quicker/more secure. Banks are already looking into this and exploring their own private blockchain network. [1]

Hasn't Bitcoin already started such a network? What would be the benefit of a private network? Will banks really be able to bring more computing power (and thus, have the largest chain) than the Bitcoin public?

<comment><USER5> Bitcoin has already seen some unfortunate consequences of running on an open network.

Chinese mining syndicates hold a significant share of control over the Bitcoin network, and are therefore able to control the destiny of Bitcoin. They decided against the Bitcoin XT fork, for example and stand in the way of its adoption.

All democratic, naturally. Possibly a good thing for Bitcoin stability.

But can you imagine American banks ceding control of their settlement infrastructure to a network / protocol whose rules could be dictated by China?

<comment> TD-Linux The rules can't actually be dictated by the miners - e.g. they can make invalid blocks but clients won't accept them. They can censor transactions, though that can only delay it until a non-colluding miner includes it.

The Bitcoin XT chain fork is a bit different in that it explicitly tied itself to miner voting. That's not necessary, you could really tie it to anything.

</comment></comment></comment></comment><comment><USER10> > The distributed ledger is a permanent, secure tool that makes it easier to > create cost-efficient business networks without requiring a centralized > point of control.

Really a fucking shame it is only business for networks.... A fish doesn't understand it is in water.</comment>


Talk on cracking Internet anonymity service Tor withdrawn from conference - <AUTHOR> http://www.reuters.com/article/2014/07/21/cybercrime-conference-talk-idUSL2N0PW14320140721

<comment><USER2> This is a dupe [https://news.ycombinator.com/item?id=8064153](https://news.ycombinator.com/item?id=8064153)

<comment><USER3> Kinda, but the Reuters article provides more/actual information, compared to the other submission.

<comment><USER4> The original article has been updated to include that information, so we'll treat this post as a dupe.

<comment><USER3> Okay. It hadn't been updated when I checked. Thanks for staying on top of this, dang.

</comment></comment></comment></comment><comment><USER5> [https://news.ycombinator.com/item?id=7998527](https://news.ycombinator.com/item?id=7998527)</comment>


NASA's Mars Rover Crashed Into a DMCA Takedown  - <AUTHOR> http://motherboard.vice.com/2012/8/6/nasa-s-mars-rover-crashed-into-a-dmca-takedown <comment><USER2> "The good thing about automation is that you don't have to involve real people to make decisions. The bad thing about automation is that you don't have to involve real people to make decisions."

Indeed and this is what scares from relying completely on Google's services.

</comment><comment><USER3> So when is Google going to scrap the automatic takedown engine already? Or are they really "cool" with stuff like this happening every now and then, even if they feature extremely important stuff like landing on Mars.</comment>


IsometricSass – Sass library to make isometric 2D without JavaScript - <AUTHOR> https://github.com/MorganCaron/IsometricSass <comment><USER2> This is amazing. Thank you! The world needs more isometric diagrams (since they're able to communicate more with no perspective diminishing). To my mind, a lot more product/service discovery could use isometric diagrams in their landing pages. In addition, visualizing app/page navigation and funnels. I really think it's untapped. I've tried to cobble together my understanding of isometric design over the years from different skillshare or lynda tutorials. I've tried Maya and other modeling applications to create more detailed models. And gone back to using the SSR approach (using Illustrator - though as an engineer I still have so far to go there - great skillshare courses by Daniel Scott). Gotten into Sarah Drasner's great design for developer courses. (Making and Breaking the Grid mentioned there is a great book.) Recently via [https://medium.com/@PepsRyuu/why-i-no-longer- use-d3-js-b8288...](https://medium.com/@PepsRyuu/why-i-no-longer- use-d3-js-b8288f306c9a) and a desire to use the minimum tools necessary to get the job done, I'm totally aligned in taking a more css only approach (eschewing SVG for the reasons mentioned in that article - particularly text wrapping).

A long way of saying this is really interesting. Thanks!

<comment><USER2> (For posterity: and.. back to SVG. Shirley Wu's d3 courses are great!)

<comment><USER2> And then there's this! [https://medium.com/@mbostock/why-you-should- use-d3-ae63c276e...](https://medium.com/@mbostock/why-you-should- use-d3-ae63c276e958)

Awesome.

</comment></comment></comment><comment><USER3> One of my first personal projects was to try to produce an isometric 2d game in javascript, I failed spectacularly but learned a lot. Thank you for not just a really cool library but reminding me of that childhood trial!

</comment><comment><USER4> Oh, this is fun!! I've had a game idea bouncing around in my head, this could be quite useful. Thank you for sharing.

</comment><comment><USER5> Your CSS/Sass skills are indeed gold!

My next game will be using this.

<comment><AUTHOR> Thanks :) Do not hesitate to make a pull request to add your game in "Your Projects" at the bottom of the documentation [https://morgancaron.github.io/IsometricSass/](https://morgancaron.github.io/IsometricSass/)

</comment></comment><comment><USER6> Wow time to uninstall photoshop.</comment>


Money does buy happiness - <AUTHOR> https://medium.com/i-m-h-o/money-does-buy-happiness-cd23d0f6517a

<comment><USER2> Yeah, no.

I can't buy prowess in craftsmanship I care. I can't buy meaning of my work and life. I can't buy time spent with close friends (not mere acquitances Americans call friends).

Lack of money can ruin all these, but once I have just enough to not bother much with cost of living, I don't really care.

Not everyone wants to travel to foreign countries. Much less people make anything meaningful out of such trips. You have been to Egypt and seen pyramids? OK, so what? It's not like you are second Edward Atkinson. You probably were on an organized trip and have several photos, that's all.</comment>


Online hackers threaten to expose cartel's secrets - <AUTHOR> http://www.chron.com/news/houston-texas/article/Online-hackers-threaten-to-expose-cartel-secrets-2242068.php

<comment><USER2> If this is a bluff, They have blown their single shot.

If this is not a bluff, they owe the world the list of names, no matter what.

So what is the optimal strategy for the cartel? Release the captive and wreak terrible vengeance if Anonymous doesnt hold up their end of the bargain? Call the bluff?

<comment><USER3> Since the information Anonymous claims to have is probably already known to the authorities or at least suspected, I doubt the cartel fears its release.

The cartel's optimal strategy is probable to kill the hostage in some gruesome and horrible way, as a message to Anonymous to stay out of their business.

Anonymous can attack governments and corporations and individuals because all of those generally have to go through legal channels to fight back. The Mexican drug cartels do not give a damn about legal channels.

Anonymous are like kids that have been throwing rocks and taunting animals at the zoo, and now think they can safely get away with taunting a grizzly bear they've run into in the woods.</comment></comment>


New notarization requirements from macOS 10.14.5 onward - <AUTHOR> https://developer.apple.com/news/?id=04102019a <comment><USER2> The crowd here tends to interpret code signing requirements as nefarious steps down a slippery slope where Apple locks down macOS and applies draconian rules to deny us access to our own computers. The reality is a little more boring:

macOS has a growing malware problem. The initial solution to this was to introduce the Mac App Store in 2010, where users could acquire trusted apps that had been vetted by Apple.

But the Mac App Store wasn't successful by many measures and users continued acquiring apps elsewhere, including the occasional malware. So in 2012, Apple introduced Developer ID, tying every app to a developer identity which is supposed to be verified through the Apple Developer membership application. This means malware cannot be released by a nameless entity, and that it can be revoked.

However, having recently cleared off a relative's computer of something like 5 separate "Adobe Flash updaters" all signed by different, and apparently fake, developers, it seems that the $99 membership fee and identity verification was not enough to deter fraud and abuse in the program.

The logical next step to protect users is to give Apple more insight into what is being signed, so that they can be more proactive in detecting and blocking malware. Thus, notarization, which involves uploading a copy to Apple.

Apple's software engineering org is populated by some of the developers of your favorite open source projects and indie apps. They're not trying to destroy the platform that they love. In the past, they've given advanced users an escape hatch---option-click to run an unsigned app, Gatekeeper settings, System Integrity Protections settings---and I hope this doesn't change in 10.15. But they are trying to balance this with the needs of 99% of users who just want their Mac to be protected from malware.

</comment><comment><USER3> "Notarization is not App Review. The Apple notary service is an automated system that scans your software for malicious content, checks for code-signing issues, and returns the results to you quickly"

If they truly mean this, and only check done is for malicious content then it does not sound that bad except the ~100$ developer account each year to be paid to Apple. Tim Cook needs to be aware of developers being one of the main legs when it comes to creating a happy user base. If he treats them as second class citizens, then making shareholders happy will not last long.

</comment><comment><USER4> It seems like we keep losing more and more control over what we're allowed to run on our own machines.

<comment><USER5> Comply with the App Store or die :'(

<comment><USER6> Comply with a commercial operator or use free software. Make sure to buy hardware which supports such from the get-go, especially make sure the hardware can not be disabled or crippled by the manufacturer for violating some nonsensical licence. In plain English this now means "don't buy Apple hardware" as this platform is hostile to free software (e.g. T2 chip which shuts down the machine when 'unlicensed' software (read 'Linux') is used, etc).

</comment></comment></comment><comment><USER7> I wonder how does it affect Hackintosh community?

<comment><USER8> Probably not at all, they will just disable the checks or add another certification authority.

<comment><USER9> Hm, maybe time to run "Hackintosh" on a Macintosh.

<comment><USER10> How about no. When I don't have to pay 2x for an Apple laptop, ridden with thermal and keyboard issues and to carry dongles for everything ("but it's so thin!"), I'll be very happy to.

Until then, my X1E, which is durable, maintainable (still to an extent), has all the ports I might need, light, doesn't throttle, while more powerful, cost 1.7x less on top of that, AND running Mojave - will be making me happy, thank you very much.

</comment></comment></comment></comment><comment><USER11> No problem, I'll just add installation instructions to my software for users to disable notarization. Perhaps even an AppleScript, .pkg installer, or Terminal command to copy-paste to make the process easier.

<comment><USER12> No problem, I'll just remove software that requires me to disable notarization.

<comment><USER11> Your loss</comment></comment></comment>


Show HN: AIFiddle, a Web GUI to Design, Visualise and Share Deep Learning Models - <AUTHOR> https://editor.aifiddle.io/ <comment><AUTHOR> The landing page can be found here: [https://aifiddle.io/](https://aifiddle.io/)

A video intro here: [https://www.youtube.com/watch?v=7Pz9UyRcA9w](https://www.youtube.com/watch?v=7Pz9UyRcA9w)</comment>


Kernel state based fuzzer: a LLVM approach - <AUTHOR> https://github.com/hardenedlinux/harbian-qa/blob/master/syzkaller/kstate_resource.md <comment><USER2> I'm vaguely familiar with fuzzing (sending auto-generated malicious input to an API to see if it fails), but there is a big gap between my level of understanding and the level of this document. How do I fill in the gap?

<comment><USER3> More than likely the point of the share, sow confusion within the minds of the uninitiated.

<comment><USER4> And why would someone want to do that? To dissuade people from looking into fuzzing? That seems self-defeating (people usually want as many other people working on the tools they use as possible), but maybe I'm being naive and this is a clever long-lead-time cyberwar gambit or something.

<comment><USER3> No one ever has ill intentions in software.... Nothing to see here, move along....</comment></comment></comment></comment>