GOPHERSPACE.DE - P H O X Y
gophering on hngopher.com
HN Gopher Feed (2017-11-29) - page 1 of 10
 
___________________________________________________________________
Interactive workflows for C++ with Jupyter
176 points by SylvainCorlay
https://blog.jupyter.org/interactive-workflows-for-c-with-jupyte...
th-jupyter-fe9b54227d92
___________________________________________________________________
 
rb808 - 19 minutes ago
I'd like to use Jupyter notebooks to do support tasks - eg check on
system hosts and do reports, maybe restart processes. I think it
could be perfect. I'm just hesitant because no one else seems to
use it this way. Any advice out there?
 
periram - 2 hours ago
Finally! Thanks a ton to both Cling developers and Jupyter.
Personally, a lot my programming involves prototyping and playing
with a lot of different ideas and implementations before settling
on a solution. Compiled languages put a steep barrier to this way
of thinking and that is why Python has always been my favorite.  I
have come back to C++ thanks to Cpp14, 17 and great new features
like this!!
 
gcc_programmer - 4 minutes ago
I think jupyter with C++ is an amazing idea, and I hope it will
help more people to start with, in my subjective opinion, one of
the most important programming languages today.That being said, I
look down on all the commentators who say that C++ has a primitive
build system/package manager etc. Lets be clear: C++ has no package
manager, and , in my view of the world, no compiled language has a
native build system, its just that most compiled languages dont
separate compilation from linking and also most languages support
modules :)C++ is hard. Throwing some fancy frontend and and a REPL
will only make you realise that sooner. The complexity is mostly
unjustified, but the language is so powerful that you could do
anything with it: from trading strategies to power plant control
systems to game engines. I have been studying C++ for 9 years, have
used it for 7, and have been a professional developer for only 2.5
years, and I think I have only scratched the surface. I have used
python for a lot less time but I feel like I am more comfortable
with it because Python is trivial to learn (to a person with a comp
sci background ofc). What you think you are cutting away
(dependencies/build jnfo) is something essential to learning C++
and how everything comes together. Better learn it sooner than
later imho.Rant over
 
rocqua - 2 hours ago
This looks downright amazing.I only wish it had come a few months
earlier. I've had to switch from python in a jupyter notebook to
C++ for performance reasons, and I really felt the loss of
incrementalism.
 
  cbcoutinho - 1 hours ago
  You can create your project into python library by wrapping in
  ctypes or using the cffi package. I do that with some of my
  numerical simulation code and it doesn't take away from the
  interactivity of python. Once I get a feature more or less
  complete, I re-write it in c/fortran and compile it away. This
  maintains performance as well as focus, because the 'interesting'
  thing you'll be working on is quick and dirty using python, and
  the stuff you've already okay'd is in a compiled language out of
  sight.
 
ddavis - 3 hours ago
Very cool! I watched the SciPy talk on xtensor (same developers as
xeus) and the project looked pretty awesome. Many people in my
field used CINT for a long time and cling is so much better. It's
nice to see it used outside of particle physics.One thing I
disagree with is the idea that the lack of a good interactive
environment for C++ makes it difficult to teach. C++ is a compiled
language, so learning how to compile a C++ library or program is
_part_ of C++. I feel like C++ beginners should go interactive
_after_ learning how to compile a project. I write that with first
hand experience; my first programming experience was with writing
interpreted C++ in CINT and I feel like it hindered my ability to
eventually understand what a real C++ program was.
 
  jmabille - 2 hours ago
  I agree that the compilation process is part of the C++, however
  (and that's from my teacher's experience), teaching it to
  beginners as a first lesson may be complicated (and you have to
  teach it early so they can build their first program). Besides
  this is not rewarding when your students are familiar with other
  languages like python where they can write some code and have
  immediate results without any additional step.So having a good
  interactive environment is really useful for the first lessons,
  then you can teach the compilation chaintool and switch to a real
  environment.
 
  pjmlp - 3 hours ago
  C++ on environments like C++ Builder is relatively easy.The issue
  is developers having open mind to such environments, luckily it
  seems to be changing with QtCreator, CLion, VC++, specially
  thanks to clang being implemented as a library.
 
peheje - 1 hours ago
Cool. For anyone looking at using Python when speed is important
should also take a look at Numba.
 
muxator - 1 hours ago
> Most of the progress made in software projects comes from
incrementalism. Obstacles to fast iteration hinder progress.I would
like to print it in very big letters and put it at the entrance of
slow-moving IT departments. "cost of change" is likely one of the
most important metrics to measure the effectiveness of a team.Being
risk adverse because of fear of change leads to stagnation."more
Jupyter notebooks and less spreadsheets" could be a useful
simplification for conveying this change of POV.
 
  taeric - 52 minutes ago
  And yet,"more data in spreadsheets" is a truism.  The spreadsheet
  model is empirically one of the most successful ones we
  have.Worse, so called "notebooks" are neat, but they are just as
  bad for engineering best practices as spreadsheets are.Not to say
  that you shouldn't be able to grow from freeform practices.  You
  should.  Just don't mistake them for being somehow superior to
  spreadsheets.
 
aldanor - 31 minutes ago
I can?t help mentioning my own project -
https://github.com/aldanor/ipybind - which provides a lightweight
Jupyter interface to pybind11 [1], allowing to quickly sketch
working C++ extensions in the notebook; all features of pybind11
like numpy support are immediately available. Been using it myself
quite a lot for prototyping C++/Python code.[1]
https://github.com/pybind/pybind11
 
mcemilg - 2 hours ago
Okay. If its works amazing, so it can be work on other compiled
languages? This will be amazing and it can be game changer.
 
FlyingSnake - 3 hours ago
C++, despite being a really powerful language, has a really
primitive build system. Developers have to wade through a complex
soup of Makefiles/CMake/Gyp/ninja etc just to get a project set up.
There's conan for package management, but it pales when compared to
Cargo or Gradle. Moreover setting up Conan is a full time job in
itself, and it's not without weird quirks either. I've not tried
Bazel yet, and would love to hear if it's as good as Xooglers
say.C++ on Jupyter looks amazing, and I really hope it makes
starting with C++ easier.
 
  harry8 - 32 minutes ago
  Cake https://github.com/dcasnowdon/CakeWritten by Matt Hermann
  who I believe is now at google - I've never met him. I worked
  somewhere that used it and have used it ever since for every
  greenfields C++ project I've done and just don't think about my
  build system anymore. For me this just works for everything I
  need, adding a linkflag for this .cpp file only? Dead simple,
  hard to imagine it being simpler. Build tests and run with
  valgrind equally so. I have a single top level makefile that
  literally just specifies targets, eg release, test, asan_test,
  clang_release etc. Each is a single cake line.I highly recommend
  it for C++ on linux (haven't used it elsewhere to say), for me
  it's a thing of beauty and a joy forever. Not dealing with
  autotools or scons or complicated make based build systems makes
  C++ so much nicer to work with.
 
  thenewwazoo - 1 hours ago
  I'm a bit surprised to read this. It's been a long time since
  I've done C++ outside of the embedded space, but isn't this a
  problem that's solved by libraries and LTO? Compiling individual
  source units isn't terribly difficult either. There's a single
  tool that turns source files into object files, and a single tool
  to link them all up. It all feels very UNIX-y to me.
 
  coherentpony - 1 hours ago
  > Developers have to wade through a complex soup of
  Makefiles/CMake/Gyp/ninja etcBut you do this precisely once.
 
    mschuetz - 1 hours ago
    Once every week.
 
  malkia - 20 minutes ago
  Bazel is what I really like (xoogler here, used it mainly with
  java+protos, minor python/c++, testing, other things). Similarly
  - gn (though different internals, easier platform switch, etc.),
  buck, pants, etc.In all of these I like the single "BUILD" file
  per directory, and simple text file explaining dependencies.
  bearable to use (yet).Also these tools work awesome when you are
  in a company, and you have underneath - dozen or more libs, sdks,
  projects that need to run together.
 
BeetleB - 2 hours ago
It would be great if we get C++ on Jupyter. At the moment, I use
Org Babel to do these kinds of things. It's a halfway solution.
 
harry8 - 23 minutes ago
This is how I'm doing C++ rapid interactive. Combined shell and C++
in a single file that compiles itself and either runs itself or
runs objdump on itself. I find it really useful and fast to test
something in junkcode. Not quite the same problem as interactive
C++ with Jupyter but there's some overlap. Overlap with godbolt as
well - find this quicker perhaps because I'm more used to
it?https://github.com/hal88/junkcode/blob/master/template_scrip...I
post in the hope that it is a useful idea to someone and also that
people respond with their similar ideas that might be useful to me.
 
kasperset - 1 hours ago
How is it different from R notebook implementation of C++ chunks
execution?