
PolyConf 2015 – A multi-disciplinary conference for polyglot programmers - albanlv
http://polyconf.com/
======
noir-york
Shouldn't programmers be polyglot by _default_. It's like saying there is a
conference for golfers who play with more than one club!

~~~
fragmede
Only if you think of programming languages as an individual golf-club.

Put it this way: Is there a conference for professional basketball, baseball
_AND_ ice hockey players? I'm not even aware of anyone who managed to go pro
in two of those, not to mention all three.

Most programmers have a preferred domain and language. Once you scale past a
pet project and have a decently sized team, specializations start to occur,
especially as the code base grows beyond what one person can hold in memory.

I'm reminded of the saying "jack of all trades, master of none".

~~~
bitcrusher
Bo Jackson was both an NFL and MLB player.

[http://en.wikipedia.org/wiki/Bo_Jackson](http://en.wikipedia.org/wiki/Bo_Jackson)

~~~
jghn
As was Deion Sanders, but the GP didn't give football as one of his sports

------
awjr
Do people really only programme in one language? The simple act of connecting
to a database and retrieving data by definition requires knowledge of 2
languages. What I think people do do, is silo themselves onto specific
technology stacks (e.g. Microsoft solutions).

~~~
eitally
I'm shocked you're asking that question. Most programmers are vocational and
work for corporations. Most corporations try to force standardization. As a
result, most programmers are significantly stronger in one language/platform
than any other (whether they have any experience in others or not, which they
usually will).

As a dumb example, when XMLHTTPREQUEST hit the streets, it was a paradigm
shift in enterprise, but a pretty easy one for web developers to add to their
toolbox. Years pass.... When everything became javascript, that was much
harder, especially for the .Net folks who came from a VB6 background rather
than a pure HTTP/TCP/CGI background. Lots of companies are still in infancy
with adoption of modern front ends, mostly because their programmers are not
polyglots and actively resist learning new things... and you can't just
abandon hundreds of legacy apps through hiring better educated, modern web
developers with the limited budget most companies have.

A few years ago we made a decision to shift from a .Net (+MSSQL+JQueryUI)
stack to a Java stack, mostly for licensing cost avoidance after MS raised the
price of SQL Server dramatically with 2012. More than three years later, >90%
of our internal apps are still .Net and only a handful have been released on
our new preferred stack (Java/PostgreSQL/Bootstrap/Angular) and probably only
10% of the programmers are competent enough to work independently using the
new tooling.

This sad state is an area where there's a lot of naivete among _young_
programmers and startups. The corporate world just doesn't work in remotely
the same way. ... ironically, a lot of "progressive" corporations end up
creating mini-Innovation teams internally with their best & brightest, who are
told to "act like a startup" and end up basically creating 75% of all the new
stuff ... until it requires an interface to a legacy system and the devs
outside the team refuse to cooperate out of fear.

Oh, it's a mad, mad world.

~~~
erikb
Shocked? Really?

While I'm certainly stronger in one language I'd say it's quite normal to use
at least 3 programming languages daily. As a Unix guy it's even more. If I
just want to write a Python hello world I need to know some Python, some Bash,
some Vimscript, some Terminal I/O. Many of my projects also have Makefiles,
additional bash scripts (which includes SED and AWK besides Bash). Interaction
with databases, APIs, JSON or XML or INI configs, HTML, etc is also common.
And let's not forget that most systems that have grown over the years have a
few DSLs to interact with their tools.

So before I finish my first coffee I've probably used 6 languages already on a
typical work day. I think most coders in my company are fluent in at least 10
programming (&related) languages. And while our software development team is
certainly better than my last gig I still hope it's not the top of what
software dev teams can be.

And your most prevalent point is that company enforces some language usage.
It's often not the same if you switch. So if you have more than 5 years you
probably can increase the typical programming language fluency about 50%.

Also your example about switching stacks. Your first stack had .Net, C#, SQL,
JS and JQuery. Now you at least sometimes also use Java, and whatever
Bootstrap/Angular require.

~~~
eitally
I know exactly what you mean and I agree, but your scenario doesn't cover most
enterprise web developers, who likely live in Visual Studio or
Eclipse/NetBeans/IntelliJ 95% of their day, especially if there's strict
separation of duties and they aren't allowed to directly touch the DB
server/admin console.

I got fed up with this state of affairs a few years ago and stopped looking
for .Net or Java developers and started looking for self-described hackers,
assuming that would increase the odds that they had some passion for
programming and could/would/had pick up whatever tools they needed for the
job. It has worked well.

As an aside, though, especially in countries like India, Brazil, Mexico,
Chile, Bulgaria, Poland, and others which are low cost recipients of
outsourcing dollars, "software factories" are common, and in places like this
it absolutely is common for an individual programmer to literally spend their
time all day, every day doing the same one type of thing. Imho, the higher the
CMMI number, the worse this gets (the pinnacle is the "just write a function
to pass this test. No, it doesn't matter what it's doing or what this software
is for. Just pass the test.", where developers on the front line are plug &
play cogs who don't even know what they're working on).

~~~
erikb
Interesting. Haven't thought about this kind of businesses and you're right,
there might be many more such developers than people like me.

------
artumi-richard
Does anyone know of a conference that takes a wider view of the job of
programming? It has always felt to me like the focus is all about our tools,
because tools can look cool, but I'm interested in the process of starting
with a messy list of requirements and getting to a completed project in the
most successful way, which is often the real challenge in my work.

~~~
johnwards
Yip: [http://theleaddeveloper.com/](http://theleaddeveloper.com/)

------
hliyan
I almost thought they were referring to _this_ Polyglot approach:
[http://en.wikipedia.org/wiki/Polyglot_%28computing%29](http://en.wikipedia.org/wiki/Polyglot_%28computing%29)

That would have been... frightening.

~~~
userbinator
That's what I thought too before I clicked... but I'd certainly be quite
interested in attending such a conference.

------
petercooper
Nothing against this conference but on the "now have", aren't things like
OSCON or Strange Loop technically multi-language cross-pollinated programming
conferences? Or is the way some of the talks are about joining two languages
the unique draw?

~~~
zaiste
PolyConf founder here; the title is indeed misleading, OP exaggerated. There
are many great conferences in the same spirit that existed before. And Strange
Loop is our primary inspiration.

------
spot
The best tool for polyglot programming is the Beaker Notebook:
[http://BeakerNotebook.com](http://BeakerNotebook.com)

Set a variable in one language and use it in another, work with multiple
languages on the same page, including javascript, and run them all
interactively.

~~~
Blackthorn
Hey, that's a really neat product! Thanks for linking. I've never even heard
of this before and I wonder why.

~~~
spot
Thanks! It's a joy to work on and we are hiring, especially front-end and
full-stack web developers. Work on open source on github, use angular, based
in NYC.

Email me for more info.

------
kriro
Good conference to have in general. I'd suspect most programmers have a
natural interest for different languages/paradigms but practically using them
in concert often reveals subtle problems.

I have a decent background in Prolog (hardly an expert) and know it's often a
good tool for the job but often shy away from using it regardless.

I hope the "Erlang in multi-lingual systems" talk (all of them for that
matter) will be available later :)

"Why should you learn to program Commodore 64 this year?" sounds like the
exact kind of talk I'd enjoy.

Prices seem very fair and I love that a %age goes to CodeStarter.

~~~
aflinik
If you're curious about the Commodore 64 thing, the speaker is launching a
series of screencasts as well: [http://64bites.com/](http://64bites.com/)

(disclaimer: the author is my friend, but still highly recommended!)

------
jgrahamc
I did an interview at QCon this year ([http://www.infoq.com/interviews/John-
Graham-Cumming-Polyglot](http://www.infoq.com/interviews/John-Graham-Cumming-
Polyglot)) where I was specifically asked about 'polyglot programming'. The
question totally surprised me because I'd never thought of myself like that
because it doesn't seem to me that it's anything special at all.

------
jawns
Did anybody else read through the (English language) conference website for
the (presumably English language) conference, and wonder to themselves, "Why
... Poland?"

I'm not knocking Poland, but it seems strange to have an English-language
conference there and not offer anything in the way of explanation for the
choice.

I mean, I'm sure there _is_ a reasonable explanation (central location,
picturesque setting, low costs, fits the ethos of a polyglot conference,
offers the possibility of both a conference and a vacation) but I find it
strange that the explanation isn't more visible.

~~~
joeevans1000
In that case, if the conference is in, say, New York or Miami, shouldn't that
then need an explanation as well?

~~~
jawns
Only if the conference is in Polish. :)

------
erikb
What is a Polyglot programmer? A programmer who speaks more than his native
language (e.g., for me it's German, English, Chinese)? A programmer who codes
in more than one language?

~~~
igravious
Yeah, the latter.

See here [http://www.techrepublic.com/article/developers-are-
calling-i...](http://www.techrepublic.com/article/developers-are-calling-it-
quits-on-polyglot-programming/) for instance

Or here [http://radar.oreilly.com/2013/11/polyglot-programming-
what-i...](http://radar.oreilly.com/2013/11/polyglot-programming-what-is-it-
and-why-should-you-be-using-it.html)

Basically the big G is your friend?

------
hamhamed
Admins of the conf may want to embed this map on their page ;)
[https://www.stay22.com/embed/polyconf-2015?promptembed=true](https://www.stay22.com/embed/polyconf-2015?promptembed=true)

------
aaggarwal
Can someone help me understand how is the polyglot approach to software
development different from normal software development?

~~~
dagw
Polyglot approach involves picking the 'best' language for each micro-task and
then trying to get them all to interact and play nicely to each other. The
more 'normal' approach is to pick 1-3 languages that are "good enough" at all
the necessary tasks.

~~~
aaggarwal
But then wouldn't this require a bigger team with vast expertise or a lot of
time compared to a more normal approach, and it will only result in marginal
performance improvement, which might not be important in most of the regular
projects?

~~~
dllthomas
"Best language for a task" isn't meant to refer to performance of code (except
secondarily when the task is highly performance sensitive) but rather the
language in which it is easiest to accomplish the task.

------
Dewie3
I'm interested in programming languages. But I don't know if I'm really a
_polyglot programmer_. Ideally I want to be able to rely on a handful of
languages for the vast majority of things that I want to do. If I'm being
idealistic, maybe it would be possible to rely on two, or even just one.

But this "one" language would probably have the power to express its own EDSLs
for different domains and problems (like Lisps). So in effect, maybe you could
say it's many different languages in one. So why not just use many different
programming languages instead of one extensible one...?

Because general purpose programming languages seem to end up feeling too
monolithic when considering that they might only be used by you for _that one
thing_. Consider two approaches: have one language that solves problems in
domain A really well. Then you want to solve problems in domain B really well.
But the first language is not suited for that. So you use a totally different
language for that. Maybe it has its own interpreter/compiler/library and
specification. Maybe you need to interoperate between these languages. What do
you do? Inter-language communication seems to be in a sorry state, if the Unix
philosophy of "strings anywhere" is the prevailing philosophy. I guess we're
supposed to use Json now, perhaps? Corba is dead. I saw a thick old book about
it where I work and didn't feel inspired.

Compare that to having a language where you can express domain B more clearly
in the first language. It turns out that there was some friction and ceremony
with expressing domain B in the first language, but being able to express this
as as EDSL -- maybe by using something like macros -- gets you 90-100% of the
benefits of using a totally new language. Additionally, there is less
underlying complexity -- you have one language derived from the other using
constructs from the original language. And ideally you can inspect and unfold
this implementation; go through a few layers of macros, perhaps. Contrast this
with having two _wholly separate_ languages with their own runtimes, libraries
and what have you.

This might be a philosophy of building layers of languages -- actually,
probably more like a tree. Or maybe a DAG if you have several implementations
that express the same DSL. Contrast this with several distinct implementations
of monolithic languages, which probably have no knowledge of each other
(languages tend to end up shallowly similar, but subtle in many many small
ways; probably Turing Complete which makes analysis tricky or at least not
straightforward, certainly not reliable...). But when looked at in isolation
they look simple; hey this language is really good at expressing X. It doesn't
have that many user-visible constructs. Simplicity! Only when you look at the
bigger picture, you see how much effort and code that goes into implementing
software that is subtly different, only to give the _feeling_ of simplicity
when looked at more in isolation from the whole overarching system.

Some people will look at you in horror if you suggest using a powerful and
expressive language. A language that can effectively express a lot of
'languages'. They find things like operator overloading disgusting, because
code should look uniform and it should be "obvious" what it is doing. Then
they choose to involve 12 different programming languages on a project,
because that is _obviously good engineering practice_. _The right tool for the
job!_ The fact that they have to learn and deal with so many languages is
apparently trivial to them. The difference between the semantics and
ecosystems of a dozen different programming languages is simpler then learning
about and judiciously using operator overloading, I guess.

I am not trying to diminish the need for programming languages -- they seem
incredibly hard to design, and the more I read about them the more I get
convinced of that. There are ever more considerations that they can choose to
care about, potentially at the expense of something else immediately next to
it or maybe something far away. It doesn't seem like the ones who are
designing them are close to converging on designs that express many of the
problems that programming languages can/should care about. I look forward to
seeing more language (designs) -- hopefully ambitious ones. :-)

tl:dr; I should learn a Lisp. Code truly is data, or it should be. But not
even Lisp is able to do everything with sufficiently many macros, it seems.

