jRuby allows a developer to run Ruby applications in a Java Virtual Machine. Adam Kalsey from Tropo explains why you'd want to do that, what jRuby can do for you, and show how Tropo uses jRuby in building a real-time communications cloud service. Includes how to deploy apps on jRuby, and some of the pitfalls to watch out for.
jRuby allows a developer to run Ruby applications in a Java Virtual Machine. Adam Kalsey from Tropo explains why you'd want to do that, what jRuby can do for you, and show how Tropo uses jRuby in building a real-time communications cloud service. Includes how to deploy apps on jRuby, and some of the pitfalls to watch out for.
Dmytro Bignyak, RoR Dev tells why he prefers Clojure to Ruby recently:
- what's the purpose of Clojure;
- why using it;
- myths;
"Хочу розповісти про мету використання такої мови програмування, для чого її можна використати сучасному програмісту, розвіяти деякі міфи які існують." - тому буде готуйте питання і аргументи!
Dmytro Bignyak, RoR Dev tells why he prefers Clojure to Ruby recently:
- what's the purpose of Clojure;
- why using it;
- myths;
"Хочу розповісти про мету використання такої мови програмування, для чого її можна використати сучасному програмісту, розвіяти деякі міфи які існують." - тому буде готуйте питання і аргументи!
Great design patterns are reusable, modular expressions of what’s going on in your code. They allow you to communicate to other developers simply by the way you code, in addition to being easily maintainable themselves. Put simply, patterns are the available tools in the developer’s toolbox.
In this presentation, I review a few common patterns, their advantages/disadvantages, and how they can be implemented.
The source for this presentation can be found here: https://github.com/derekbrown/designpatterns
tl;dr - How will the everyday developer cope with Java 8’s Language changes?
Java 8 will ship with a powerful new abstraction - Lambda Expressions (aka Closures) and a completely retooled set of Collections libraries. In addition interfaces have changed through the addition of default and static methods. The ongoing debate as to whether Java should include such language changes has resulted in many vocal opinions being espoused. Sadly few of these opinions have been backed up by practical experimentation and experience. - Are these opinions just myths?
- What mistakes does a developer make?
- Can a ‘blue collar’ Java Developer cope with functional programming?
- Can we avoid these mistakes in future?
In London, we’ve been running a series of hackdays trying out Lambda Expressions as part of the Adopt-a-JSR program and have been recording and analysing the results. Huge topics of mailing list discussion have been almost entirely irrelevant problems to developers, and some issues which barely got any coverage at all have proved to be a consistent thorn in people’s side.
Lambda Expressions: Myths and Mistakes - Richard Warburton (jClarity)jaxLondonConference
Presented at JAX London 2013
tl;dr - How will the everyday developer cope with Java 8’s Language changes?
Java 8 will ship with a powerful new abstraction - Lambda Expressions (aka Closures) and a completely retooled set of Collections libraries. In addition interfaces have changed through the addition of default and static methods. The ongoing debate as to whether Java should include such language changes has resulted in many vocal opinions being espoused. Sadly few of these opinions have been backed up by practical experimentation and experience. - Are these opinions just myths?
2013-02-21 - .NET UG Rhein-Neckar: JavaScript Best PracticesJohannes Hoppe
Of course, a presentation about JavaScript should be made with HTML5 & JavaScript. So, here it is! Enjoy the show at http://johanneshoppe.github.com/JsBestPractices/ . You might also want to fork it on GitHub (https://github.com/JohannesHoppe/JsBestPractices) or save it as an old-fashioned static PDF from Slideshare.
talk at Virginia Bioinformatics Institute, December 5, 2013ericupnorth
Extensible domain-specific programming for the sciences
The notion of scientists as programmers begs the question of what sort of programming language would be a good fit. The common answer seems to be both none of them and all of them. Many scientific applications are a combination of general-purpose and domain-specific languages: R for statistical elements, MATLAB for matrix-based computations, Perl-based regular expressions for string matching, C or FORTRAN for high performance parallel computations, and scripting languages such as Python to glue them all together. This clumsy situation demonstrates the need for different domain-specific language features.
Our hypothesis is that programming could be made easier, less error-prone and result in higher-quality code if languages could be easily extended, by the programmer, with the domain-specific features that a programmer or scientists needs for their particular task at hand. This talk demonstrates the meta-language processing tools that support this composition of programmer-selected language features, with several extensions chosen from the previously mentioned list of features.
The presentation shows major features of the new C++ standard (language and the library). The full list of new things is very broad, so I've categorized them to be easier to understand.
Scala 3 Is Coming: Martin Odersky Shares What To KnowLightbend
Join Dr. Martin Odersky, the creator of Scala and co-founder of Lightbend, on a tour of what is in store and highlight some of his favorite features of Scala 3!
This is my attempt at a look at some of the features of C++11, and more importantly, describing some of the style changes in C++11 that will make programmers more productive and programs more efficient.
A fast-paced introduction to Deep Learning concepts, such as activation functions, cost functions, back propagation, and then a quick dive into CNNs. Basic knowledge of vectors, matrices, and derivatives is helpful in order to derive the maximum benefit from this session. Then we'll see a short introduction to TensorFlow and TensorBoard.
2. nescala 2013
2 days event in Philadelphia
Day 1: 17 talks
Speakers from typesafe, twitter, tumblr, ...
Scala book authors: Bill Venners , Josh Suereth
Day 2: unconference
$50 entrance fee
3. Function Patterns for the
Asynchronous Web
by Josh Suereth @ TypeSafe, author of Scala in Depth
5. Future
ftr {
uue
/ D smtm ltr
/ o oeie ae
..
.
}mp{rsl =
a eut >
/ D smtigwt rsl
/ o oehn ih eut
..
.
}
6. Monadic Flow
dfrne(aa DRsl) Ftr[tl =ftr(tl..)
e edrdt: beut: uueHm] uueHm(.)
dfhnlRqet..:Ui ={
e adeeus(.) nt
fr{
o
dt < qey..
aa - ur(.)
hm < rne(aa
tl - edrdt)
}yedwietlsce,hm)
il rtHm(okt tl
}
7. Join
vlues Ftr[beut =
a sr: uueDRsl]
qey..
ur(.)
vlpoet:Ftr[beut =
a rjcs uueDRsl]
qey..
ur(.)
vldt:Ftr[DRsl,DRsl) =
a aa uue(beut beut]
(sr zppoet)
ues i rjcs
Ls[uueDRsl] - Ftr[itDRsl]
itFtr[beut] > uueLs[beut]
8. The Essence of the Iterator Pattern
Jeremy Gibbons and Bruno C. d. S. Oliveira @ Oxford University Computing Laboratory
Monadic Map
Applicative Functors
Monadic Applicative Functors
...
10. Not only for Dependency
Injection
tatUeRpstrCmoet{
ri sreoioyopnn
vlueRpstr:UeRpstr
a sreoioy sreoioy
casUeRpstr {
ls sreoioy
..
.
}
}
tatUeSrieopnn {
ri srevcCmoet
ti:UeRpstrCmoet=
hs sreoioyopnn >
vlueSrie UeSrie
a srevc: srevc
casUeSrie{
ls srevc
..
.
}
}
11. Traits are modules
tatUeMdl {
ri sroue
dflaUe(d Ln) Ue
e odsri: og: sr
}
tatTetoue{
ri weMdl
dfps(srd Ln,bd:Srn)
e otueI: og oy tig
}
tatMSLsroueetnsUeMdl {..}
ri yQUeMdl xed sroue .
tatTitroueetnsTetouewt UeMdl {..}
ri wteMdl xed weMdl ih sroue .
vluies =nwMSLsroue
a nvre e yQUeMdl
wt Titroue{
ih wteMdl }
12. Package is just a namespace to avoid name collision. So,
instead import, use extends/with
Explicit dependencies
13. Interesting problem #1
tatA{
ri
vlfo Srn
a o: tig
}
tatBetnsA{
ri xed
vlbr=fo+"ol"
a a o Wrd
}
casCetnsB{
ls xed
vlfo="el"
a o Hlo
pitnbr
rnl(a)
}
solution: use def or lazy val
14. Interesting problem #2
tatA{
ri
ojc suf{
bet tf
ojc Fo
bet o
ojc Br
bet a
ojc Bz
bet a
}}
tatBetnsA{
ri xed
ojc ma {
bet or
ojc Fo
bet o
ojc Bz
bet a
ojc Br
bet a
}}
solution: use val
15. abstract override
tatTat {
ri riA
dfmto1l Ls[tig) Ls[tig
e ehd(: itSrn]: itSrn]
}
tatTat etnsTat {
ri riB xed riA
oerd dfmto1l Ls[tig)=l: "riB
vrie e ehd(: itSrn] + tat"
}
tatTat etnsTat {
ri riC xed riA
asrc oerd dfmto1l Ls[tig)=sprm
btat vrie e ehd(: itSrn] ue.e
to1l : "riC
hd() + tat"
}
casCas {
ls lsA
ti:Tat =
hs riA >
dfso( {pitnmto1Ls(Cas") }
e hw) rnl(ehd(it"lsA))
}