It's a hard real-time language for avionics software, BUT it has type inference and duck typing (everything is "symbolic"). SolScript is supposed to look familiar to anyone with a basic knowledge of mathematics. It's also a literate language, because every SolScript file is a Markdown file (and SolScript code is inside Markdown code blocks).
[link redacted]
Also there seems to be no actual proof of safety of the language's semantics (are the semantics formally specified?), but perhaps I missed it.
The compiler can find out the range of numbers and the lengths of lists using static analysis, because SolScript is such a "restricted" language. Functional programmers would probably dump all that information into a type system. We call it "dataflow analysis", but I think the end result is the same.
Note that, all of the static analysis is done on the dataflow graph underlying a SolScript program. In the dataflow graph there are no "functions" or "classes"... The static analysis is much simpler because it is done on something more primitive than the language itself.
- avionics
- type inference
- duck typing
You like challenges don't you? ;)
I like the literate component a lot, I can see why that would be a very big plus when you're building avionics software.
Bookmarked your thesis.
What was your reason for going for 'duck typed' and 'scripted' rather than strongly typed and compiled? (Which I would assume to be a whole lot more suited for the intended branch of industry, so that has me curious.)
At the surface of it this looks like a 'textual spreadsheet' with the lines replacing the cells of the sheet.
This 'spreadsheet' is then evaluated 'x' times per second to satisfy the hard real time requirements.
How do you stabilize the results from one 'tick' to the next? Do you keep a shadow copy that you work on with all the results posted to the next generation?
There is something funny about a person working for a small software outfit choosing a format for textfiles (for really good reasons) because Microsoft or Apple might not be around when the files need to be read. I get your reasoning and agree with it completely but you have to balance that against the chances of your own company not being around anymore either.
How much of the software of the original Boeing 747 is still in use today? I'd imagine there are no fuselages that have not been upgraded multiple times since the first 747's took flight. So the lifespan of the documentation is roughly the same as the lifespan of the software.
Are there any public sources out there?
Here are some of the oldest 747 airframes known to be still on active duty:
http://www.airliners.net/aviation-forums/general_aviation/re...
But that does not say much about the avionics in them.
Do you intend to release the source to solscript in order to profit from the 'many eyes' out there to reduce the number of bugs in the runtime? (Which can't be written in solscript, so effectively will have to be written in some unsafe language.)
I like that markdown trick a lot, that's applicable to just about every programming environment, see:
http://michael-sokol.tumblr.com/post/13112309135/literate-pr...
I say SolScript is "duck typed" and "scripted", because that's how it feels to program SolScript. However, under the hood, SolScript is a statically typed, compiled language.
About the "spreadsheet" idea, that is exactly what the SolScript IDE (Solide) is going to be. There will be a spreadsheet mode, which displays the source code as a spreadsheet. The last chapter talks about Solide, if you want to know more. (The creation of Solide is going to be my job, and I've been watching Bret Victor videos, all day yesterday, for inspiration.)
We have no "deep copy" of the data. The data is simply mutated in place, for performance. The compiler knows in what order it has to update the datacells, so SolScript users don't notice any of this. If I say `b = a`, then `a` will be calculated before `b` uses it. (If you want the value of `a` before `a` is updated, you say `b = previous a`.)
The whole "plain text" argument is about the fact that companies can die. So can (UN)MANNED, of course. The difference is that plain text files will always be readable, in contrast to Word files. You don't need our software to read plain text documentation.
Releasing the source is not something we plan to do (for now). We are not against the idea, but right now we have other priorities. There will probably be a gratis version, even for commercial use. Only that version won't be certified.
Yes, SolScript is written in an "unsafe" language: C. This makes it extremely cross-platform. We can run on Linux, OS X, Windows, iOS, VxWorks... The coding standards of our C code are extremely strict. Avionics style.
And about Markdown, yes that could be applied to other programming languages. BUT SolScript integrates with Markdown on a whole new level. For example, sections in Markdown are the scopes or namespaces of a SolScript program. Markdown is built into SolScript, not tacked on.
Edit: Circular dependencies really make no sense, in a declarative programming language. Defining `a = b` and `b = a` has no clear meaning, so the compiler will throw an error. However, you can define things recursively using `previous`. For example: `a = b + 1 initially 0` and `b = previous a`. In this case, `b` is 0, 1, 2, 3... and `a` is 1, 2, 3, 4...
My paper is in german, but I'll publish it on github and translate it (time given). I've also got a hypothesis on how FRP can be abstracted into a domain model using AI and non-axiomatic reasoning. But I hope I don't run in a dead-end there though, it's just a theory :)
In the future, there will be a website dedicated to SolScript itself. This website will be the "technical" website. We already have a domain [2], but there's no website there.
Right now, we are working on getting SolScript into production. This thesis was really the first time anyone ever wrote anything about SolScript. Part of my job, in the future, will be to write blog posts and create tutorials. I'll definitely keep HN posted!
Reactive programming is ill-defined and over-hyped, so let's talk about types and math instead (plus some not-very-subtle in-jokes about Microsoft).
An enumerator is basically a getter with the ability to fail and / or terminate. It might also return a promise rather than a value. An enumerable is a getter that returns an enumerator. We can express all this very cleanly in generic types. And if we take the category-theoretic dual of these types we get the observer and observable types.
So who needs reactive? ;-)
I think the description of events as just another collection, albeit a time based collection flow was nicer ( Observable === Collection + Time ), and also that this collection must have the ability to tell you that it has terminated.
If you want statically typed functional programming, but also functional programming that stands a chance of adoption in many environments, then Scala is about your only choice.
This is the first time I've heard of reactive and read HN everyday.
> Java's enumerable( Iterable?) is broken
anyone know what how its broken?
Take a look on GitHub at all the projects with reactive in the name or descriptions; it's become a buzzword that people use to describe various things that don't have any relationship to the original.
Iterable is broken, as Erik said, because it has a hasNext() method, and a next() method, which is a problem because hasNext() causes side-effects to be evaluated.
Imagine if the implementation of the iterator has to execute a long running function, or wait for the next value in an observable to be pushed, like an event. So, if call hasNext() twice, then it may cause a side effect so that next() actually has a different result than it would without the side effect. Thus, it is not mathematically, a function, and can't really be used to build monads.
So, unfortunately, due to backwards compatibility, Java classes that implement Iterable/Iterator can't automatically get the benefits of list monads etc..., by simply defining a library of operators that take Iterable/Iterators, like C# could with IEnumerable/IEnumerator.
In C#, IE only has side effects in the MoveNext() method, which returns true or false if there's another element, and the effect is explicit in the name, which helps. However, more importantly, if you get the value from Current, there is no side effect, and you can do that as many times as you like.
With Iterable, if you call next() it moves to the next element. So, it is impossible to get the same value twice with a guarantee of no side effects, and impossible to guarantee mathematically sound composition of Iterables. The interface is broken, and changing it would break nearly every Java program.
You're not paying enough attention. There were tons of articles on reactive on the front page, at least 1-2 per week, for the last year or so. See also: "functional reactive programming". See also: "React.js". See also: "Om".
https://www.google.com/search?q=site%3Anews.ycombinator.com+...
The speaker mocks his audience of Microsoft engineers (like not in fun, he is really saying their culture sucks).
He is dismissive of "reactive programming" as nonsense from architecture astronauts, without giving a remotely fair description of what it actually is. His straw-man of "var x = 10; println(x); x = 42; println(x)" is not reactive, because "x" is not a function of other mutable state in the model. I've never heard of reactive programming until five minutes ago, but I can tell this just by reading the Wikipedia excerpts from his own slides (and a little follow-up reading confirms this).
I'm all for rabble-rousing, but if you're throwing punches you should know what you're talking about.
At 17:30 he makes a joke about a Steve Jobs function that says "iPhone", "iPad", "iCloud", and then "terminates naturally". Holy bad taste.
EDIT: others have pointed out that with extra context this is more obviously a self-deprecating and good-natured shtick.
> He is dismissive of "reactive programming" as nonsense from architecture astronauts, without giving a remotely fair description of what it actually is.
That's because his presentation is from React 2014, so he can fairly assume that the audience has some idea of what he's talking about, because "reactive" is the freaking topic of this audience - http://reactconf.com/
> if you're throwing punches you should know what you're talking about
Well, he kind of does. He's one of the architects of Reactive Extensions (Rx) and now he's contributing to RxJava. I don't agree with many of his opinions, for example I think they made design mistakes while architecting Rx, but he's OK in the knowledge department ;-)
> At 17:30 he makes a joke about a Steve Jobs function that says "iPhone", "iPad", "iCloud", and then "terminates naturally". Holy bad taste.
He also makes the same joke about himself - was trying to explain how streams are terminated, either naturally or by error (the joke on himself was that he was fired, i.e. onError).
My reading and feelings concerning the Manifesto mirror Erik's so I enjoyed listening to his mockery of it. I didn't really notice the MS bashing.
The issue with the Reactive Manifesto is that it is largely waffle. There are styles of programming that account for time, such as functional reactive programming. They tend to have formal definitions, or at least concrete implementations, so one can make objective statements about them. The Manifesto on the other hand is vague and full of platitudes. It's great for the Pointy-haired Boss, but there is little of substance than one can discuss in any objective manner.
[Update] I can understand how it's off-putting to listen to the presentation without this background.
[1] http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-B...
Ironically, I think you completely missed his point, probably because of an unfamiliarity with his background and history. He's not dismissive of reactive programming at all, quite the opposite! For example, he gave a course on Coursera about Functional Reactive Programming with Martin Odersky and Thomas Kuhn[0].
So my take on it is that he's just making fun of himself and his friends in a typical blunt Dutch fashion. Which of course doesn't work if you don't know the context.
And I don't think he's being dismissive of reactive programming, he's dismissive of that definition, which is too broad. He was one of the main proponents of Reactive programming inside Microsoft.
http://en.wikipedia.org/wiki/Erik_Meijer_(computer_scientist...
