News for hackers. Stuff that matters.

ohpauleez

Re:Learn C and build your own Lisp (2014) on Wednesday June 23, 2021 @06:55AM (#27603018)
I also have had this thought - start people with very simple (C89) C and Scheme. When they learn data structures have them use C and scheme and show additional examples in class in Python/Java/JavaScript. When they take an AI class, they build the fundamentals in Lisp and see examples/ecosystem in Python. When they take some form of "Programming Languages" they get introduced to SML and see some Java+ANTLR. When they take Software Design I and II, they work in Java.

From that foundation, they'd have the exposure they need to expand out.

I also enjoyed the path my University took. You started with Java. Data Structures was in C++, Java, and Python. Operating Systems was in C. AI was in Common Lisp (with some examples in Java and Python). Programming Languages was in any language you wanted, but examples were mostly in C and SML (SML/NJ). Computer System Design was in HDL, Assembly, and C. Software Design I and II used Java. Requirements Elicitation and Specification used Z. Concurrent/Distributed systems I and II used Promela, SPIN, TLA, and code was in Java.

Kevel is hiring Clojure devs as well! https://www.kevel.co/careers/
In case you haven't seen the applications of nanopass compilers to do similar things, specifically harlan, here you go: https://github.com/eholk/harlan
This largely sums up my experience with Alloy and TLA+, as well as when I favor using one tool over the other. My formal education included classes in Z, so the spirit of Alloy always made sense to me and it's usually the tool I start with (I tend to see systems problems as relations, the tooling is fantastic, the REPL is very useful, counter-examples help illuminate the problem space, etc.) When my problem is strictly algorithmic or it's all about the evolution of state spaces over time (especially concurrent states over time), I lean towards TLA+.

When my problem is strictly a state machine, I usually write out some combination of a Parnas table and a statechart, and then encode the table into Alloy.

I have a little tutorial I use to teach teammates the basics of TLA+ and Alloy, which takes about two hours to get through. I find that within a week of using Alloy, folks are dangerous enough to get value out of it.

In addition to what alex posted, the new package system along with the build system means that you can build a custom OS based on Genode in under under an hour (my fastest build takes 5ish minutes). The core/base kernels are also packages in Genode, which means you just "shop" for everything you want: a base kernel, services, packages, libs, etc.

It's not perfect and it could use slightly better tooling (which will come once everyone is convinced the design is completely correct), but it's the best system for an OS I've seen to date.

Re:Software Foundations on Monday November 27, 2017 @10:06AM (#15787825)
Adding to what tel said:

Alloy will tell you where things are over or under-specified. You can ask the system to generate you scenarios in the "world" so you can see a graphical representation of states. You can test/check your assumptions or operating criteria against the structures/rules of the of the "world" and it'll find and show you counter-examples where things fail. I especially like working in Alloy because it's incremental and interactive, like a REPL for you design work, providing some of the benefits of property-based testing in the design portions of creating your system. Simply put: It helps you think through and explore your design!

Re:Qubes OS: A reasonably secure operating system on Monday November 20, 2017 @08:07AM (#15739616)
Genode now has its own package management system with the 17.05 and 17.08 releases, informed/inspired by the work from Genode/Nix (linked in the other comment).

This means you can run Genode on NOVA with VirtualBox 5 fully integrated as the VMM, all with the improved Noux/POSIX interop components in place, and have a decent package management solution (that handles API compatibilities, multiple version installs, src vs binary deps, packages, and more). There's also Xen support with the most recent release (for cloud appliance work with Genode)

What's more, based on the roadmap and challenges, they should be bringing VirtualBox5 support to the seL4 kernel, and they even have a goal for being the virtualization foundation of QubesOS. https://genode.org/about/challenges

With the recent toolchain update and new package management system, its easier than ever to cook up your own Genode-based systems.

Re:Ferret – A free software Clojure implementation on Tuesday August 08, 2017 @06:23AM (#14956270)
I'd also add that support in Vim and Neovim are also very good.
Re:Subgraph OS: Adversary resistant computing platform on Friday November 25, 2016 @06:41AM (#13036008)
You can go and use Genode right now. There's no installer (to my knowledge) -- you'll have to build the OS by hand. If the area of secure OSes or capability-based OSes are interesting to you, Genode is the best playground for that. The DROPS/Dresden folks have been working in this area for a long time.

Genode is largely kernel agnostic, being an "Operating System Framework" -- you can run it on Linux, variants of L4, seL4, Muen, and more.

Re:Ask HN: Best linux laptop for developers on Wednesday November 02, 2016 @07:51AM (#12853770)
The Zenbook line has dual and quad core machines, high-resolution screens, up to 16Gb of RAM, aluminum bodies, the ports you want, a great touchpad (and often touch screen), and an NVMe SSD. It's wonderfully supported by recent Linux releases (4.4 and up).

I switched from a MBP to a Zenbook about seven months ago, running Ubuntu 16.04, without any issues.

This is the model I have: https://www.asus.com/us/Notebooks/ASUS-ZenBook-Pro-UX501VW/

Re:Clojure.spec – Rationale and Overview on Monday May 23, 2016 @12:14PM (#11754778)
Important to note, that as data, they can be consumed by other systems for other purposes. For example, it's feasible to consume a spec within Alloy and use a SAT solver (which is made even easier given the split on keyset). This pushes spec from design and requirements validation, into runtime constraints, and on through to tests and verification.
It's a finding from a Capers Jones report (I believe on the analysis of agile vs waterfall projects of varying sizes and durations). I'll see if I can dig up the exact report for you...
I appreciate more attention being given to software estimates, but it seems like there's a lack of looking at the research in this area of software engineering. Most people have a single hocus-pocus equation that generates numbers they find convincing. Furthermore, it's often the case that these numbers are never changed over the life of the project.

That would be like predicting the weather with a single model, once, for the next three months. Of course that isn't going to work.

There are a few key points I think are often overlooked:

* Estimating is less about understanding time, and more about sizing a project and effort -- a study in software economics.

* Bottom-up estimates need to be based on historical performance. They should always be ranges and should include a notion of confidence. They should be democratically created if you're estimating for a team. You can do something simple (like Estimatr) or use a tool with a lot of data behind it (like Personal Software Process) - I do both.

* Top-down estimates should also be used. I often use COCOMO and COSYSMO, with monte carlo risk calculations (http://csse.usc.edu/tools/COCOMOII.php).

* The two approaches will give you two answers (both in ranges), with confidence intervals, which provides you a better sense of the size of the effort.

* Generating and publishing an estimate has a psychological effect on the team - consider that wisely (read Peopleware).

* Estimates are good for about two weeks, after that, they've become stale.

* You're not done with a project until you've recorded your performance data (for future bottom-up estimates).

* If a project is going to last three months or less, the research shows that nothing matters at all -- estimates, process, etc. -- do whatever keeps you/the team motivated.

While I like the foundation of this idea, I'd love to see it taken to the next logical conclusion: Drop HTTP for a better suited protocol (like 9P), and correctly handle the interaction of union'd (namespaced) filesystems.
Re:Reader macros in Common Lisp on Monday October 19, 2015 @01:29PM (#10414325)
While I appreciate the dialog, your comment is rather condescending. I've worked extensively in Common Lisp and am well aware how the condition system works. My claims had little to do with conditions, and more about the benefits and use - It's pretty simple to have a dynamic var (say, handler), bound to anything you like, catching errors before the stack unwinds, including an expression-based REPL debugger, allowing you to change locals and return a value in the place of the exception. It has all the limitations you can imagine, but for many cases, this is plenty to be effective.
Re:Reader macros in Common Lisp on Monday October 19, 2015 @07:44AM (#10412263)
While there are no first-class reader macros in Clojure, reader literals cover many common use cases. For the small set of use cases where you REALLY need reader macros, it's possible to hack them into the language. One such implementation: https://github.com/klutometis/reader-macros

As far as interactive debugging - that's also something I missed from CL, but is relatively easy to hack into the language. A combination of REPL support for the standard JVM debugger (https://github.com/ohpauleez/cdt), with a nice expression-based REPL debugger (https://github.com/ohpauleez/cdt/blob/master/src/cdt/debug_r...) gets you pretty far. You can even trigger this environment on any exception using the built-in JVM support (https://gist.github.com/ohpauleez/4ca0b646b89512f38ea2#file-...)

To see how far you can take reader literals, hack a look at my talk from last year's Conj, "Unlocking Data-driven Systems" - https://www.youtube.com/watch?v=BNkYYYyfF48

Capability-based OSes have been around for some time, largely developed by the team that produced DRoPS, Fiasco, and other L4 based systems (as tonyhb pointed out).

Those advances are mostly from the Dresden OS folks, and the NICTA group (which went on to make one of Qualcomm's best kernels, OKL4).

seL4 was an attempt to convert the API and specification for the L4 kernel into an executable format (using Haskell) and confirm the specification was solid. The system was then extended to actually test the L4 kernel itself.

In the most recent versions, you can run entire device drivers and OS layers under the capability management system. One only needs to look at the Genode tooling (which is the logical continuation of the work started in DRoPS): http://genode.org/documentation/general-overview/index

Genode, Fiasco.OC, L4 (including seL4), and the work on secure GUIs all deserve to be far more popular than they are.

Re:Show HN: OJ – A Clojure library for talking to your database on Thursday November 06, 2014 @07:02AM (#8566644)
It's also worth mentioning Pedestal[1] - in place of Ring and Compojure. Pedestal is set of libraries for building web services that is fast and secure by default. It fully embraces async capabilities (unlike Ring which is inherently synchronous), and maintains most Ring compatibility. It sits upon battled-tested technologies (Jetty, Tomcat, JBoss, Undertow, etc).

[1] https://github.com/pedestal/pedestal

Maybe I can answer the why a little better:

The short answer is: This opportunity is everything that matters most to me - a great startup with a real vision and a team that believes in execution, the ability to have a real impact in the company as well as in the community, the ability to follow some of my passions and share some knowledge, and to work on a problem that makes a real difference in people's lives.

We're not just going to be a ho-hum tutor marketplace, we're going to pull out all the best pieces of information and knowledge to make a real difference for education.

To me, that's worth moving back across the country for.

I'm glad to hear it! Good things are coming.