HNHacker News
TopNewBestAskShowJobs

mands

753 karma · joined March 31, 2011

Co-founder at pumpup.com
submissionscomments
mands··on The Rise and Fall of CORBA (2006)
Thanks so much.

Yes, we've pivoted a few times, first starting out with trying to be the 'github for live API's, which is an idea we love but found that the chicken-and-egg situation was tricky to overcome, and that most users just wanted a way to deploy their code to the code to support a webservice.

As such we pivoted to building a shared hosting service that let's users just write their code and deploy it.

Regarding your 3 questions, my preliminary responses would be (bear in mind we probably would need to think about this further!),

1) We were super excited by the idea based on our own use cases - I found it a nightmare trying to build a distributed back-end to process video in the cloud for a previous startup. This got in the way of building my product but had to be done. Similarly, my co-founder ahead ran into the same issue when he needed to perform web-rendering on the server and just needed an easy way to wrap up this functionality. At this point we though perhaps we could use containers to wrap up the code but found the container ecosystem was focussed heavily on dev-ops and not services, so we built this.

2) Yes, totally agree - our messaging needs a lot of work, we've actually become a lot better in real life but unfortunately haven't updated the website to reflect this!

The basic problem is that deploying your code to the cloud is hard. After writing your code locally, you have to do all kinds of orchestration to get your code into the cloud, run it at scale, handle faults, client integration, and more. We feel we can make this simpler.

As for why you'd want to move your code to the cloud, hmm, that's a good question. Why the cloud? Don't worry about physical infrastructure., have capacity and capability to scale up compute resources dynamically, ignore hardware maintenance and amortise sys-ops costs with other users.

Getting across why users want our code to get to the cloud, if they know what the cloud is, is tricky. Absolutely, becoming an easy way to get code into the cloud followed after this, as we realised just how hard it was. We've moved to the cloud but our tools haven't.

3) Yes, this is the hard bit. Lots of users have existing code, perhaps in the cloud already or locally deploy. They don't know or care about Docker / Kubernetes, etc - and shouldn't have to. We think Docker is a great building block to build services on top of, but we should be able to abstract it away and build on top of it. Eventually we'd hope we can get across our core message - deploy your code to the cloud as easy as running locally - without ever mentioning containers, docker, and more. Perhaps we can do that now, we just to update our message to get that across.

For now we're thinking of targeting client-side JS developers as an initial niche and going deep with that while we figure out our tech and message. but yes, the core message is the same - a really simple way to write some code and get it hosted in the cloud as simply as possible (and yes, with a free tier also). It can, and should, be simpler.

mands··on The Rise and Fall of CORBA (2006)
Hi - thanks so much for all the feedback and advice. Have just seen it and will reply fully in the morning (we've been super busy pitching for our accelerator's demo day in the UK - which is an awful excuse!)

Really really appreciate you taking the time out to reply and to investigate the tool. Would be great to get on a call sometime and discuss your thoughts further - my email is my HN username @stackhut.com. Thanks again!

mands··on The Rise and Fall of CORBA (2006)
Sorry for the delay - was on a break from HN

Yes, I think you are right, the availability of XML/ws-* acted as a magnet for people who required extensive schemas, etc.

I agree that JSON is a great starting place for the rest of us who don't have such immediate needs for complexity and get can by with it. But I think eventually software growth then pushes them to more complex interchange format, e.g. JSON schema.

I think that there is progress, with JSON on the simpler side, and now newer formats like ProtoBufs, Thrift and mechanisms such as RPC - we do seem to be learning from the past. It does feel that perhaps we do swing from one extreme to another - first RPC was great and CORBA came and went, following this the perception was that it was utterly unsuitable for anything, until perhaps the introduction of ProtoBufs, Thift, JSON-RPC and so on. I personally think it can be incredibly useful, but deciding on just the right features to keep things manageable is incredibly difficult (more so than the tech itself I believe).

We're no fans of JSON-Schema either, I've thought about it a few times but it feels over-complicated. Instead we've settled/forked a criminally overlooked system called Barrister RPC (http://barrister.bitmechanic.com/). This just supports basic JSON types, structs created from their aggregate, and optional nullability. It has worked great so far, although we may expand shortly to add more numeric types. You can try it live at http://www.stackhut.com (source at http://www.github.com/StackHut) - would love to hear your thoughts re the schema/RPC layer.

mands··on New View of Microservices
Great work - looks really cool, esp for ppl using the Node stack. Really excited by the progress in the space, with products like this, JAWS (https://github.com/jaws-stack/JAWS), hook.io and more.

At StackHut (www.stackhut.com) we're working on something similar, a micro-services based system that's provides a scalable, typed, JSON interface into JS/Python classes wrapped up in containers.

Can't wait to see where this microservices-based path ends up...

mands··on The Rise and Fall of CORBA (2006)
I agree that getting just the right amount of simplicity is actually a hard challenge. JSON over HTTP feels like it has won as it was so trivial to implement in any language, however experience has taught me that the lack of a schema causes problems over time.

At StackHut (www.stackhut.com) we're using JSON with a lightweight schema. So far this is working very well, providing simple yet 'typed' remote interfaces into containers. However I often wonder about switching to XML/XML-schema/XML-RPC, protocol buffers/gRPC or some custom system in the future or to just keep it simple and not over-complicate things.

mands··on Show HN: StackHut – A language-agnostic Lambda for cloud and local microservices
Hi, cofounder here. Thanks for looking and your feedback!

Yes, pricing is something we're still debating on and hope to decide by next week - whether to a charge a flat rate per request or to make it dependent on computing resources used.

As for private vs public services, the wording could definitely be clearer - it basically determines if requests can be made to a service by anyone or if authentication and tokens are required. I understand the confusion tho, it came about as we were initially looking to create a GitHub of live APIs that would all be public however users told us they were more interested in hosting their own private code.

Yep, language support and pricing are massively important for us, we aim to get most other dynamic languages supported ASAP (ES6 and Python already there, Ruby on the way) and follow with compiled languages after (Go is top of the list).

Thanks again - super useful and would love to hear how you got on if you decided to deploy a service!

mands··on Phoenix 1.0
Thanks all for your responses, really helpful!
mands··on Phoenix 1.0
Slightly off-topic, but can someone familiar with both Elixir and Erlang explain what Elixir provides in comparison to Erlang.

I'm looking into using Erlang for a new project that requires extensive scaling and concurrency and am coming from a functional background so may be more comfortable with the traditional Erlang syntax. However it seems that perhaps more development and activity is happening on the Elixir side of things and it may be more productive in terms of tooling, libraries (such as Phoenix and Ecto), and support.

Thanks!

mands··on Show HN: JAWS – A JavaScript and AWS Stack
Thanks so much for looking, sorry that the public APIs didn't work correctly. I've ran a few tests and most work apart from the `pdf-tools` demo for converting PDFs - thanks for raising that to our attention (the life of a beta product!). Can I ask what browser you're running?
mands··on Developing V8 with Guix
Apologies for the confusion - I assume call-with-container talks to the required kernel functionality directly instead.
mands··on Developing V8 with Guix
That's great to hear, thanks for the work, I look forward to trying it out. Using Guix with systemd-nspawn sounds like it could be a formidable combination.
mands··on Developing V8 with Guix
I'm a big fan of Guix/Nix and would love to see them in greater use.

Whilst I agree that they provide many of the reproducibly benefits of containers, isn't the other big advantage of containers the (theoretical) security benefits they bring? i.e. a process can't break out of its container and access other data.

Perhaps I'm missing something but can such isolation be provided by Guix/Nix?

mands··on Show HN: JAWS – A JavaScript and AWS Stack
Great work - looks like a really useful piece to help you quickly get going using the AWS stack and Lambda/JS. The biggest issue I've always found is the extra steps between writing your code and getting it onto a server.

The "no server" movement definitely seems to be gathering steam, with Firebase and Parse on the data side and Lambda (augmented with JAWS and others) on the computation side. Am excited to see what this area will bring, in particular due to the combination of scalable hosting and containerisation.

(Plug - we're working on StackHut (http://www.stackhut.com) in the "no server" space that provides a language-agnostic Lambda-like platform (currently JS/ES6 and Python with Ruby soon) that's powered by Docker and is accessible via JSON-RPC over HTTP. Would love to hear your thoughts on this and the "no server" space in general.)

mands··on RESTful considered harmful
JSON-RPC always works well and is quite simple. I often find it easier to just use JSON-RPC and clearly mark which methods are remote than to try and fit my remote semantics into correct HTTP verbs and status codes.
mands··on RESTful considered harmful
I agree - JSON-RPC is simple to use, parse and understand. Plus I feel it makes more sense when you are triggering computations remotely rather than querying.

At StackHut (http://www.stackhut.com) we're hacking on a platform that takes code you've written and hosts the API in the cloud over JSON-RPC. We think it's pretty cool and would love to hear from others doing interesting stuff with JSON-RPC.

mands··on Introducing Incremental
Great to hear, sounds like an fascinating project and look forward to trying out the AWS library. Funnily enough the project I considered using OCaml for was to build a language & runtime for container orchestration.

Yes, OCaml dev seems to be picking up again - I used to use OCaml/JoCaml a few years ago but moved to Haskell and F# in the meantime. However am very excited by the work on Flamba, multi-core and hopefully modular implicits, as OCaml always felt most natural.

mands··on Introducing Incremental
Looks like really cool tech - at a first glance reminds me of the UI.Next reactive rendering model in WebSharper/F# (http://www.websharper.com/docs/ui.next) which also has an OCaml/ML heritage.

Have been thinking about using OCaml again for a new project - does anyone know the state of libraries for common web tasks, like AWS, these days?

mands··on Why Go and Rust are not competitors
I certainly see the need for Rust, a better, stricter and more modern C designed for low-level tasks where both performance and correctness matter, e.g. layout engines, game engines, OS kernels.

On the other hand Go seems more suited to system/server tools where good-enough perfmance and quick startup matters more. I've noticed that people have been converting Python and Ruby code-bases to Go, and its use in system tools such as Docker, CoreOS, and Kuberentes. We're working in this area and have considered jumping on the bandwagon and rewriting our Python prototype in Go for the same reasons - performance, minimal runtime, strong ecosystem, some 'typing'. (Python made/makes sense atm as we're still very exploratory so doesn't get in our way).

However upon investigation I was a bit disappointed with Go, although it has an incredible ecosystem and active community. Perhaps its simplicity is also an advantage although I found it counter-intuitive at times. However I can see why it found use in a way that 'better' (IMHO) tools such as OCaml were unable to.

We're still undecided as to what to use when/if rewriting our code. Funnily enough I'm wondering if maybe C#/F# would work, now .NET has been open-sourced and has a native compiler. A good language/runtime, stronger type-system, lots of libraries, and potentially good performance with quick startup. I guess it would be quite amusing if MS's tooling ended up as the best way to write Linux system/server tools within those particular constraints.

mands··on The Sikhs who saved Parmesan
I hope, perhaps naively, that maybe AAP have a chance to root out that particular dynasty. I remember they polled pretty well at the last election but am not sure how things worked out on the ground afterwards.

As a member of the diaspora I wonder what more can be done from the outside?

mands··on Apple's digital crown mess
Aesthetically it's great - but that user interface just seems incredibly confusing to me. Perhaps it works when you use it in person. Does anyone know how the Android Wear UI compares?
mands··on First Impressions Using React Native
> I would kill to be able to do React in F# or OCaml.

Websharper (http://websharper.com/) for F# is now Apache-licensed and comes with the UI.Next framework that provides a really nice reactive paradigm for creating web UIs. Unfortunately it doesn't help with mobile apps as React Native does but is still pretty good.

mands··on WebSharper 3.0-alpha under Apache license
Great news! WebSharper is fantastic for developing integrated server and web-client systems from a single F# codebase. Hopefully under the Apache 2 license both development and uptake may increase.

Have been very impressed with the UI.Next client-side framework that was previously in beta.

mands··on How did Apple forget to focus its product line-up?
Interesting article. I wonder if the multiple, older, models are just a way to clear excess inventory or if Apple really believes this allows them to complete on cost as well. For instance the price difference is still excessive when comparing the 5C against mid-range Android phones at which point if you are buying Apple you may as well go for the top-range iPhone anyway.
mands··on Teaming up with Oxford University on Artificial Intelligence
I'm not sure I'd agree that CS has a low profile within the UK, I think it's had a strong history over the past 70 years or so. And now there seems to be a buzz regarding bringing coding into classrooms at a lower age that will hopefully will boost numbers in the future.

I guess the low number may be as it is taught in a traditional manner with a focus on the theoretical fundamentals rather than on software engineering (although the dept does offer a post-grad part-time Software Engineering course I TA'd for that seemed pretty cool.)

Anyway, this is certainly good news for the department (and congrats to Max too!).

mands··on WebSharper: Make web apps in F#
Thanks for taking the time to write up such a detailed comment. I was working on one of my own as I have had nothing but a great experience with Websharper and was disappointed to see the tool be somewhat dismissed by (to me) unfounded and unproven technical and license concerns.

I'm using the tool to develop the web front end for a MVP idea. Combined with Xamarin it means I can use F# across my entire application stack. This means reusing the same types, domain models, and so on. Plus you get all the goodies of Async, computation expressions and strong typing on the web client.

I went straight to the new UI.Next reactive framework and have been loving the experience to build a SPA. Imagine Om/React but strongly typed with monadic combinators to compose reactive views.

I guess this is a long way of saying 'second' :)

mands··on Windows 10 Technical Preview download now live
Downloading now at around 0.5MB/s.

Tempted to put this on my main dev machine as many of the desktop changes will really aid my workflow but will probably wait until the weekend at least just in case.

mands··on Xamarin Acquires Petzold
That is true. I have a Xamarin plan for use with Visual Studio for developing mobile apps in F#.

However I'm just keep running into stumbling blocks and general frustration developing in Windows, having switched from 10yrs of Linux purely for VS. With the general improvements in Mono and the open sourcing of F# I'd love to use them all together on Linux and take advantage of the greater OSS developer ecosystem there.

Monodevelop/Xamarin Studio is fine for development, more so with the newly-added split-view, and the F# support is pretty much on a par with VS these days, but without Xamarin.Android/iOS support I simply can't move.

Maybe I should suck it up and buy a Mac instead.

mands··on Microsoft announces the Surface Pro 3
Also checkout Cmder (http://bliker.github.io/cmder/) for a pre-customised ConEmu that bundles several useful UNIX commands. Plus ConEmu supports Quake-style dropdown that has radically improved my work-flow on Windows.

Also Powershell is pretty awesome if you take the time out to learn it.

mands··on India's pro-business Modi storms to historic election win
What good is an apology from Congress when they stonewall any attempts for an independent inquiry into the 1984 riots and still harbour known instigators and accomplices at a high level within the party?

On the other hand, several senior BJP officials were tried and convicted for their part in the 2002 riots.

mands··on Sharp Develop – Open Source Alternative to Visual Studio
I recently used it on a 2010-era netbook that couldn't handle the full VS2013 Express edition and it worked great. Not as many bells and whistles, but easy to use and quick to get up and coding.
← PreviousPage 4 of 5Next →