
Leapfrogging the IDE - amasad
https://amasad.me/leapfrog?hn=1
======
rpeden
A couple of observations:

\- Something like Light Table would probably seem like a step up for repl.it
users, instead of a step down.

\- It can take a long time to reach the point where it feels like there's a
big payoff from using IDEs and similar tool.

 _Now_ , I definitely see the value of being able to do something like set a
breakpoint in Visual Studio, step through a bit of code and observer local
values changing, and then step _backward_ , change the value of some variables
or even edit my code a bit, and then step forward again to observe how my
changes impacted the execution of the code. But when you're just learning,
it's hard to even know that this kind of time travel debugging and live
editing is even _possible_ , and even when you know it's possible, it can be
difficult to envision how you'd want to use it until you have more experience.

~~~
amasad
I think for someone not familiar with repl.it and just reading this might get
the impression that we are anti-IDE features. That is not at all the point. In
fact we think Code Intellisense is essential. We start a Language Server for
many of the languages that we support:
[https://repl.it/blog/intel](https://repl.it/blog/intel)

~~~
kstenerud
I think part of the problem is your home page, because it doesn't say anything
about what your product is, or what it does, or what your mission is, or how
it helps me.

I went to the bottom of the page to find the "about" link, which had a 1 line
mission statement that doesn't say much, and a bunch of employee pictures.

I still don't know what it is you do, other than your name which implies a
repl, which most languages have already.

~~~
amasad
Which problem?

------
zandl
I can answer the question why switch if the limited online one is sufficient;
it’s because the developer is working less efficiently and is unaware of the
impact on productivity and code quality.

I’ve seen this many times, variable renamed done with text replace or by hand,
inconsistent formatting and headers, silly bugs that an ide could catch as you
type get committed, switching between screens to test their code constantly.
Ignorance isn’t bliss, it’s just new developers aren’t getting the wisdom and
expirence of the past and are repeating past mistakes instead of improving on
the solutions.

~~~
erikpukinskis
I’ve been coding for 20 years. You are correct that some people would speed up
in an IDE but it’s more complicated than that. Many people are slowed down by
their IDE.

I see IDEs largely as a symptom of the complexity sickness in software
development. Companies take a strategy of letting complexity grow to the point
where it can’t be controlled. IDEs and other tools for managing massive
complexity emerge, because you need such tools to work in codebasses that have
become a hurricane of complexity.

There is another path, where you choose to use simpler tools and adapt your
plans to fit the tools. This is how the Amish work and they are able to do
incredible works and be highly productive.

So, yes. You can try to become like “iron man”, wrapped in tools of immense
complexity to match the tasks you set yourself to.

Or you can be like a Japanese carpenter and study and think and refine so that
you can do only small tasks, with simple tools, and see miraculous detail
emerge from the compounding interest of consistent daily practice.

~~~
FridgeSeal
There are features in PyCharm that I have found so, so useful, that I refuse
to write Python in anything else.

When Julia and Rust get support that good I’ll never have to use a text editor
+ plugins again; and I will be very pleased (even though the Rust sublime text
plugin is very nice).

------
canterburry
Coming from an enterprise background and having used Eclipse and IntelliJ for
many years, I am honestly puzzled by the current trend in IDEs such as VS
Code, Atom, etc. given their lack of fully features refactoring support, code
search which goes beyond just simple text search, native understanding of
classes, interfaces, method signatures etc.

I have tried all of the above 'modern' editors and almost immediately find
tooling i'd assume is part of every IDE (i.e. code formatting, import
organization/cleanup) but wasn't

Amongst the current crop of engineers, there seems to be a stigma against even
trying Eclipse or IntelliJ. I kind of feel like junior engineers are missing
out on discovering some much more powerful tooling and forming their own
opinions.

~~~
asdkhadsj
> Amongst the current crop of engineers, there seems to be a stigma against
> even trying Eclipse or IntelliJ. I kind of feel like junior engineers are
> missing out on discovering some much more powerful tooling and forming their
> own opinions.

For me it's the _text_ editing features that these IDEs lack. I'm definitely
giving up advanced language integration, but I _(and many)_ make the choice to
do this for more powerful and/or preferred text capabilities.

Vim, Emacs, Kakoune being my main examples. Not just a "vim mode" \- I've
never used one of those that was even remotely useful for me, heh.

~~~
kakarot
What are some text-editing features that you find IntelliJ lacking?

~~~
asdkhadsj
It's more about the style of editing. Ie, right now I massively prefer Kakoune
style editing. I choose that over Vim, despite Vim having much wider support.

When compared to Vim, it's not about one specific "feature" that vim lacks,
it's Vim, it has just about everything - it's about my editing UX, and vastly
preferring how Kakoune does it.

Now would I choose IntelliJ if it could perfectly replicate how Kakoune does
editing? Without a doubt I'd choose IntelliJ. Yet I massively doubt that's
even possible.

Fwiw, I've been dying to use a GUI editor, but I cannot give up first class
implementation of my text editing methodology of choice, be it vim, Kakoune,
etc. It's not about "is it possible to do X", it's possible to do nearly
everything in Notepad.

------
collyw
> "I have one file called index.js"

Say it all really. Online coding tools may be fine for beginners, but think it
would be next to impossible to do my work with one.

~~~
styfle
What if all the features of an IDE existed for online coding tools? I actually
maintain a list of these tools[0] and several of them are very close to the
native experience.

In particular, CodeSandbox has come a long way by basically running VS Code in
the browser.

[0]: [https://github.com/styfle/awesome-online-
ide](https://github.com/styfle/awesome-online-ide)

~~~
Filligree
They still would not be nearly as fast. When I'm working with projects
consisting of hundreds of files measuring hundreds of lines each, I need an
IDE that's capable of using the full performance of my workstation

~~~
lolsal
A counter-argument to this is that all files you need are stored in 'the
cloud' and performing searches/indexing/refactoring would happen _faster_ than
on your workstation because it can take advantage of a lot more 'cloud'
resources.

~~~
FridgeSeal
My work computer is 8 cores, 32gb and a GPU; why do you imagine that a hosted
instance somewhere running the web server is going to do a better or faster
job than my local computer? Hell, even my laptop is going to do a better job
than a cloud server.

~~~
lolsal
Not 'a hosted instance' or 'a cloud server', but many. An arbitrary amount.
Personal anecdote: Local full builds for me take 28-30 minutes. When I farm it
out to our infrastructure in AWS it takes 9 minutes.

------
beat
I don't know if this counts as the same thing, but I've recently started a
Rails-based project on Google Cloud, using the cloud shell and its built-in
editor. This is great because I don't have to futz around with a Vagrant
environment or (worse) a straight Rails dev environment on my Mac, and I can
do full-strength software development from the little Chromebook I like to
carry around.

A Chromebook plus a 100% cloud-based dev environment is a great way to work
without having to radically rethink How Software Works.

~~~
Koshkin
Just to be clear, what you carry around and enjoy using so much is essentially
a wireless terminal to a mainframe.

~~~
pjmlp
It is ironic how we rejoiced with the freedom from the mainframe just for the
current generation to go happily back to it.

~~~
yen223
Especially since absolutely nothing has changed from then to now

~~~
pjmlp
My hardware and OSes of choice state otherwise.

------
nixpulvis
I see no argument here made about hosted services like Repl.it that doesn't
also apply to a simple ol' terminal emulator, or other forms of development
environments. I feel like the real topic here is that there are effective
developer environments on the web which can be accessed regardless of walled
garden app stores.

I'm trepidatious however, since I'm not a huge fan on relying on external
services in general. "I can't code because the server's down" doesn't seem
acceptable to me. There is a _very real_ problem with mobile development
environments though, a solution I'd like to see start with the phone
manufacturers.

------
leggomylibro
I've never heard of repl.it, but the concept reminds me of a project that uses
a Javascript REPL/IDE to try to make embedded development more approachable
called 'Espruino':

[https://www.espruino.com/ide/](https://www.espruino.com/ide/)

It's nice for learning, because you can get the immediate feedback of a
terminal with physical hardware. It is extremely limiting in that you can only
have one file open in the IDE though, so it is unfortunately difficult to
justify for anything other than teaching or toy projects.

------
opcenter
I think the basic idea is sound. If all you're after is learning to program
and running little toy programs, then web based REPLs are a great choice.

My primary development environment is vim combined with CLI commands (and some
wrapping with vim plugins to simplify the workflow). However, when I want to
play around with something in Go to figure out how it works I will often go to
The Go Playground ([https://play.golang.org/](https://play.golang.org/)) and
play around there.

However, as soon as I'm done (and maybe shared my findings with a peer, which
I can't do as easily with my local vim + CLI environment) I'm back to my
regular development environment because very little that I work on is trivial
enough to stay in Go Playground.

All that said, I've seen plenty of developers who seem to get by sticking to
the basic feature level of Notepad. Whatever works for you.

------
ken
It sounds like users are trying to get back to working with a system image.

I have trouble labeling it "post-IDE". Depending on whether you consider
Smalltalk/Lisp machines to be "IDEs", it's either "original IDE", or "pre-
IDE".

~~~
amasad
I think the Lisp community invented tools that, had they been successful,
would've altered the course of history with regards to devtools. I wrote an
essay on this:
[https://amasad.me/disintegrated](https://amasad.me/disintegrated)

------
AcerbicZero
I've read the comments here, and perhaps due to my job not being purely
software development, I have a different impression of Repl.It. I'm much more
of an infrastructure guy than a developer, (DevOps? So overused) and I'm not
overly ashamed to admit I learned to code with Powershell, mostly via their
integrated scripting environment. Trying to make the switch from ISE to pure
Python was extremely difficult for me, because I was so deep into the REPL
style, and I just wasn't prepared to have things obfuscated and invisible. I
wanted to re-run specific lines of code, and determine variable values on the
fly, so I could adjust if needed.

Eventually, I learned Ruby (and abused Pry for a long time) "correctly" and
I"m re-learning Python the proper way now (and abusing pdb), mostly with VS
Code, but there are some very large gaps that are easily filled with a good
REPL, so I find myself popping over to Repl.it to test out some snippet that
isn't doing what I expect. Perhaps there is an IDE setup that would do what I
want while enabling me to be more productive, but learning a (usually lightly
documented) tool, full of various assumptions, while trying to learn the
actual language, AND get useful work done, is not an ideal combination.

------
jramsay
amasad, I enjoyed the perspective of your article. I agree an engineer with
many years of experience is going to have different expectations to someone
who is entering the profession today. I think it's similar to my perspective
on the iPad – I find it interesting but limited because my experience and
mental model of computing is very different to someone who is growing up with
an iPad in hand.

I work on the Web IDE at GitLab (among other things) which we built after we
noticed that there were a few situations in our day to day work on GitLab
where we didn't need a full local development environment, like updating
documentation or addressing simple review comments. It doesn't replace a local
IDE from me yet, but it is helpful and we hope we can make it more useful in
more situations where local IDEs have shortcomings. I think the effort and
maintenance of a local development environment is also a cost that is
frequently overlooked – reinstalling dependencies is a headache that
disappears in an automated ephemeral environment like repl.it or where we're
heading at GitLab.

But that seems like it's just an iteration on the status quo rather than leap
frogging to a post-IDE world. I think the idea of online interactive
development can go so much further. Maybe we can integrate interactive
editors/terminals/previews with our planning and code review tools so that
experimentation and exploration are easier and happen in line in the
discussions we have planning the next feature to build. I put a few dot points
down on this line of thinking last week [https://gitlab.com/groups/gitlab-
org/-/epics/533](https://gitlab.com/groups/gitlab-org/-/epics/533) but I'd be
interested to hear some of your more concrete ideas of what a post-IDE world
might look like.

~~~
amasad
> But that seems like it's just an iteration on the status quo rather than
> leap frogging to a post-IDE world.

I think the fact that you'd have a globally accessible, pay-as-you-go, zero-
setup, multiplayer programming tools is surely a different beast from the IDE.
However, it does go further than this and most of the innovation to this end
aren't coming from us but from our users and how they (an)use the system. I
can try to predict what the post-IDE world looks like, but it's better to
discover it.

------
phillipcarter
In theory, this makes sense. But I'll be cautiously optimistic about this.
We've had this sort of "app is always running and changes are seen live"
technology with Visual Basic since a long, long time ago. But that mode of
development is hardly the norm across the wide spectrum of developers.

------
i_phish_cats
Next time, please disclose the fact that you are the founder of the product
you are promoting.

------
zwaps
So I know you wanted to frame this as IDE vs. REPL, but most IDEs have REPL
built in (I think every Python IDE can open Jupyter notebooks no problem), and
the additional features just depend on context. Like, scientific computing
with Python, R or Matlab? You'll probably profit a lot from using RStudio,
Spyder or, well, Matlab. Huge projects with lots of data and many files... why
go through the pain of a html-based file management system if you can have as
many text-editors and IDEs installed as you like... I mean, the choice you
frame just isn't really a relevant question.

Instead, this is clearly a marketing article for your own product. You
specifically ask the question in your article, why would anyone install an IDE
locally, instead of using your product.

The answer seems very obvious to me: Only very few people can actually use an
online interface, such as your product, in actual production.

For me, for example, it would be a non-starter. Not only do I work with
sensitive data that I can't just upload to somewhere else, I am also often on
the road and simply do not have guaranteed internet. So I'll need a local IDE
anyway. Another reason is that the actual computing infrastructure is located,
and protected, in a local network. So I couldn't even run my code directly.
How much computing power do you actually provide? What if I actually generate
large output files? Where do they go? Like, do you just send me gigabyte sized
files over the tubes constantly? Do I have to download thousands of files from
that terrible web-interface? How do you deal with changes in massive datasets?
How do you deal with those data that need to stay local?

The whole article is just weird. The use-case for local IDEs is pretty clear,
and I think the people who actually have to use some local solution is, and
will be, larger than those who just casually write their code in your
datasets. Most people would literally get fired for using your product as you
suggest.

In fact I think the major use-case for your product is education and learning,
specifically where you code in several languages. Like, you quote some kid
asking why one would like to learn an IDE if repl.it is so cool and good.
Well, that kid is obviously learning and not leapfrogging anything. Sooner or
later, he/she will be coding in a company on a larger project and then all of
the above applies.

I also like the irony of repl.it stating its support for Open Source, while
apparently not being OpenSource itself.

------
lispm
the 60s/70s had already better tools for dial-in on mainframes.

------
GreaterFool
How is repl.it different from a bunch of other web IDEs that came and went
without leaving a mark?

~~~
adpirz
This doesn't necessarily translate to production-level programming, but I used
to teach computer science to middle and high school students. I originally
used Cloud9, and had to walk students through the process of setting up a
Github account, going through and setting up a proper dev environment,
ensuring that their file space was showing and walk them through the run
server commands. Very heavy stuff and ate into valuable time every class.

With repl.it, it was simply a matter of typing out a bitly link and hitting
enter and everything was set up and ready to go.

------
flavio81
TL;DR:

Repl.it member (amasad, see note) wants to promote Repl.it by saying that more
people are using Repl.it and thus it is the modern stuff because modern is
having "no IDE, just a modern repl" and etc. So "modern, 2018" is basically
having what Lisp developers have had since the early '80s.

* [https://repl.it/site/about](https://repl.it/site/about)

~~~
geocar
> what Lisp developers have had since the early '80s

We absolutely did not have a globally, network-accessible terminal with pay-
as-you-go computer time.

I have no experience or interest in repl.it, but I think you're understating
things somewhat.

~~~
daveFNbuck
The article seems to be saying that the advantages of repl.it are the
advantages of a REPL-based development platform, not remote access:

> With programmers growing up today being used to instant and interactive
> programming like Repl.it, Jupyter Notebooks, serverless compute, and others,
> it doesn't seem so outlandish to imagine a post-IDE world.

