PHP 7 – What changed internally? (Forum PHP 2015)Nikita Popov
One of the main selling points of PHP 7 is greatly improved performance, with many real-world applications now running twice as fast… But where do these improvements come from?
At the core of PHP 7 lies an engine rewrite with focus on improving memory usage and performance. This talk provides an overview of the most significant changes, briefly covering everything from data structure changes, over enhancements in the executor, to the new compiler implementation.
As a result of an engine rewrite with focus on more efficient data structures, PHP 7 offers much improved performance and memory usage. This session describes important aspects of the new implementation and how it compares to PHP 5. A particular focus will be on the representation of values, arrays and objects.
PHP 7 – What changed internally? (Forum PHP 2015)Nikita Popov
One of the main selling points of PHP 7 is greatly improved performance, with many real-world applications now running twice as fast… But where do these improvements come from?
At the core of PHP 7 lies an engine rewrite with focus on improving memory usage and performance. This talk provides an overview of the most significant changes, briefly covering everything from data structure changes, over enhancements in the executor, to the new compiler implementation.
As a result of an engine rewrite with focus on more efficient data structures, PHP 7 offers much improved performance and memory usage. This session describes important aspects of the new implementation and how it compares to PHP 5. A particular focus will be on the representation of values, arrays and objects.
A short talk on what makes Functional Programming - and especially Haskell - different.
We'll take a quick overview of Haskell's features and coding style, and then work through a short but complete example of using it for a Real World problem.
http://lanyrd.com/2011/geekup-liverpool-may/sdykh/
PHP data structures (and the impact of php 7 on them), phpDay Verona 2015, ItalyPatrick Allaert
We all have certainly learned data structures at school: arrays, lists, sets, stacks, queues (LIFO/FIFO), heaps, associative arrays, trees, ... and what do we mostly use in PHP? The "array"! In most cases, we do everything and anything with it but we stumble upon it when profiling code. During this session, we'll learn again to use the structures appropriately, leaning closer on the way to employ arrays, the SPL and other structures from PHP extensions as well.The impact that PHP 7 should have on data structures will be introduced as well.
From session at http://www.lambdalounge.org.uk/ on 18th April 2016. Here's the original blurb:
So, Haskell is "an advanced purely-functional programming language" which supports writing "declarative, statically typed code". It may be optimized for academic buzzwords you've never heard of but... is it any good for writing code in the way that you'd write Perl, Python, or Ruby?
What are strong types, and why are we so frightened of them anyway? Can you develop interactively in Haskell, the way you would in a dynamic language?
Does Haskell have "whipuptitude" (being able to get things done quickly) as well as "manipulexity" (being able to manipulate complex things)? And perhaps most importantly, can writing Haskell be *fun*?
Haskell is founded on decades of the finest mathematical and computer science research. Perl, quite demonstrably isn't... but why do so many Perl programmers also love Haskell?
Audrey Tang wrote the first prototype for Perl 6, Pugs, in Haskell, and coined the phrase "lambdacamel" for the substantial crossover between the languages.
What does a Perl programmer make of Haskell? What are the lessons that can be learned (in either direction). And do the languages have more in common than you might have thought?
PHP 7 – What changed internally? (PHP Barcelona 2015)Nikita Popov
One of the main selling points of PHP 7 is greatly improved performance, with many real-world applications now running twice as fast… But where do these improvements come from? At the core of PHP 7 lies an engine rewrite with focus on improving memory usage and performance. This talk provides an overview of the most significant changes, briefly covering everything from data structure changes, over enhancements in the executor, to the new compiler implementation.
Functional Pe(a)rls - the Purely Functional Datastructures editionosfameron
All new material, this time about one of the fundamental functional datastructures, the Linked List, and the overview of an implementation in Moosey Perl.
This covers some of the same material as https://github.com/osfameron/pure-fp-book but perhaps with more explanation (and covering much less material - it was only a 20 minute talk)
Scala is becoming the language of choice for many development teams. This talk highlights how Scala excels in the world of multi-core processing and explores how it compares to Java 8.
Video Presentation: http://youtu.be/8vxTowBXJSg
ITT 2015 - Saul Mora - Object Oriented Function ProgrammingIstanbul Tech Talks
Functional programming is finally a first class citizen in the Cocoa toolset! But, as you may have heard, Swift is not necessarily a pure functional language. And in embracing the functional paradigm, do you need to throw out your knowledge and experience with Object Oriented programming? Saul Mora shows that it turns out you can have your cake and eat it too!
Functional programming is all the rage. It can undoubtedly produce cleaner and more expressive code, but why switch to Scala or wait for Java 8? In fact, there are many ways to dramatically improve your Java code quality by using a more functional style today. This presentation discusses how techniques such as functional programming, using fluent APIs, and other clean coding practices can make your code more concise, more readable, and much easier to maintain. But more importantly, you will learn about libraries such as LambdaJ and Google Guava that make this possible today with your existing Java code base.
In functional programming, words from Category Theory are thrown around, but how useful are they really?
This session looks at applications of monoids specifically and how using their algebraic properties offers a solid foundation of reasoning in many types of business domains and reduces developer error as computational context complexity increases.
This will provide a tiny peak at Category Theory's practical uses in software development and modeling. Code examples will be in Haskell and Scala, but monoids could be constructed in almost any language by software craftsmen and women utilizing higher orders of reasoning to their code.
PHP 8.0 comes with many long-awaited features: A just-in-time compiler, attributes, union types, and named arguments are just a small part of the list. As a major version, it also includes some backward-incompatible changes, which are centered around stricter error handling and enhanced type safety. Let's have an overview of the important changes in PHP 8.0 and how they might affect you!
A short talk on what makes Functional Programming - and especially Haskell - different.
We'll take a quick overview of Haskell's features and coding style, and then work through a short but complete example of using it for a Real World problem.
http://lanyrd.com/2011/geekup-liverpool-may/sdykh/
PHP data structures (and the impact of php 7 on them), phpDay Verona 2015, ItalyPatrick Allaert
We all have certainly learned data structures at school: arrays, lists, sets, stacks, queues (LIFO/FIFO), heaps, associative arrays, trees, ... and what do we mostly use in PHP? The "array"! In most cases, we do everything and anything with it but we stumble upon it when profiling code. During this session, we'll learn again to use the structures appropriately, leaning closer on the way to employ arrays, the SPL and other structures from PHP extensions as well.The impact that PHP 7 should have on data structures will be introduced as well.
From session at http://www.lambdalounge.org.uk/ on 18th April 2016. Here's the original blurb:
So, Haskell is "an advanced purely-functional programming language" which supports writing "declarative, statically typed code". It may be optimized for academic buzzwords you've never heard of but... is it any good for writing code in the way that you'd write Perl, Python, or Ruby?
What are strong types, and why are we so frightened of them anyway? Can you develop interactively in Haskell, the way you would in a dynamic language?
Does Haskell have "whipuptitude" (being able to get things done quickly) as well as "manipulexity" (being able to manipulate complex things)? And perhaps most importantly, can writing Haskell be *fun*?
Haskell is founded on decades of the finest mathematical and computer science research. Perl, quite demonstrably isn't... but why do so many Perl programmers also love Haskell?
Audrey Tang wrote the first prototype for Perl 6, Pugs, in Haskell, and coined the phrase "lambdacamel" for the substantial crossover between the languages.
What does a Perl programmer make of Haskell? What are the lessons that can be learned (in either direction). And do the languages have more in common than you might have thought?
PHP 7 – What changed internally? (PHP Barcelona 2015)Nikita Popov
One of the main selling points of PHP 7 is greatly improved performance, with many real-world applications now running twice as fast… But where do these improvements come from? At the core of PHP 7 lies an engine rewrite with focus on improving memory usage and performance. This talk provides an overview of the most significant changes, briefly covering everything from data structure changes, over enhancements in the executor, to the new compiler implementation.
Functional Pe(a)rls - the Purely Functional Datastructures editionosfameron
All new material, this time about one of the fundamental functional datastructures, the Linked List, and the overview of an implementation in Moosey Perl.
This covers some of the same material as https://github.com/osfameron/pure-fp-book but perhaps with more explanation (and covering much less material - it was only a 20 minute talk)
Scala is becoming the language of choice for many development teams. This talk highlights how Scala excels in the world of multi-core processing and explores how it compares to Java 8.
Video Presentation: http://youtu.be/8vxTowBXJSg
ITT 2015 - Saul Mora - Object Oriented Function ProgrammingIstanbul Tech Talks
Functional programming is finally a first class citizen in the Cocoa toolset! But, as you may have heard, Swift is not necessarily a pure functional language. And in embracing the functional paradigm, do you need to throw out your knowledge and experience with Object Oriented programming? Saul Mora shows that it turns out you can have your cake and eat it too!
Functional programming is all the rage. It can undoubtedly produce cleaner and more expressive code, but why switch to Scala or wait for Java 8? In fact, there are many ways to dramatically improve your Java code quality by using a more functional style today. This presentation discusses how techniques such as functional programming, using fluent APIs, and other clean coding practices can make your code more concise, more readable, and much easier to maintain. But more importantly, you will learn about libraries such as LambdaJ and Google Guava that make this possible today with your existing Java code base.
In functional programming, words from Category Theory are thrown around, but how useful are they really?
This session looks at applications of monoids specifically and how using their algebraic properties offers a solid foundation of reasoning in many types of business domains and reduces developer error as computational context complexity increases.
This will provide a tiny peak at Category Theory's practical uses in software development and modeling. Code examples will be in Haskell and Scala, but monoids could be constructed in almost any language by software craftsmen and women utilizing higher orders of reasoning to their code.
PHP 8.0 comes with many long-awaited features: A just-in-time compiler, attributes, union types, and named arguments are just a small part of the list. As a major version, it also includes some backward-incompatible changes, which are centered around stricter error handling and enhanced type safety. Let's have an overview of the important changes in PHP 8.0 and how they might affect you!
I hope to communicate to developers of web apps, especially of those handles payment information, that they should be aware of what they trust when developing an app. This should make the app more secure and make the developers aware of when to update gems or certs.
A rabbit*1 presentation presented as a Lighting Talk at RubyKaigi 2015*2.
- *1 http://rabbit-shocker.org/
- *2 http://rubykaigi.org/2015/presentations/lt
URLs
- https:/www.hyuki.com/cr/
- https://blog.mozilla.org/security/2014/09/08/phasing-out-certificates-with-1024-bit-rsa-keys/
- https://ja.wikipedia.org/wiki/SHA-1
- https://aws.amazon.com/security/security-bulletins/aws-to-switch-to-sha256-hash-algorithm-for-ssl-certificates/
- https://googleonlinesecurity.blogspot.com/2015/10/sustaining-digital-certificate-security.html
Video presentation: https://www.youtube.com/watch?v=jLAFXQ1Av50
Most applications written in Ruby are great, but also exists evil code applying WOP techniques. There are many workarounds in several programming languages, but in Ruby, when it happens, the proportion is bigger. It's very easy to write Ruby code with collateral damage.
You will see a collection of bad Ruby codes, with a description of how these codes affected negatively their applications and the solutions to fix and avoid them. Long classes, coupling, misapplication of OO, illegible code, tangled flows, naming issues and other things you can ever imagine are examples what you'll get.
Talk at RubyKaigi 2015.
Plugin architecture is known as a technique that brings extensibility to a program. Ruby has good language features for plugins. RubyGems.org is an excellent platform for plugin distribution. However, creating plugin architecture is not as easy as writing code without it: plugin loader, packaging, loosely-coupled API, and performance. Loading two versions of a gem is a unsolved challenge that is solved in Java on the other hand.
I have designed some open-source software such as Fluentd and Embulk. They provide most of functions by plugins. I will talk about their plugin-based architecture.
Why we are submitting this talk? Because Go is cool and we would like to hear more about this language ;-). In this talk we would like to tell you about our experience with development of microservices with Go. Go enables devs to create readable, fast and concise code, this - beyond any doubt is important. Apart from this we would like to leverage our test driven habbits to create bulletproof software. We will also explore other aspects important for adoption of a new language.
Beginning Haskell, Dive In, Its Not That Scary!priort
Haskell can get a bit of a reputation for being this lofty, academic, difficult to learn language. This talk aims to dispel this myth and offer an introduction to this beautiful and pragmatic language. From the point of view of someone who has been functional programming in Scala and Clojure for a while now, but who has, more recently been taking a dive into Haskell, this talk will give a basic introduction to Haskell. Hopefully it will encourage anyone who hasn't tried functional programming in Haskell to dive in too and give it a go.
The talk will be a whistle stop tour of some functional programming fundamentals in Haskell from basic data structures, logic constructs, functional transformations, recursion to some of the basics of Haskell's type system with data declarations and type classes.
An Elephant of a Different Colour: HackVic Metcalfe
Slides from my GTA-PHP Meetup talk about Hack which is the Facebook version of the PHP programming language which runs under their HHVM runtime environment for PHP. The focus of my talk was the language improvements that the Facebook team has added to PHP.
There's a lot of information in the presenter's notes, so if you're interested in Hack scroll down to see the extras.
Crafting Custom Interfaces with Sub::ExporterRicardo Signes
Everybody knows about Exporter.pm: you use it, and if someone uses your module, they don't have to type quite as much. We'll look at how the Exporter works, and how it fails to take advantage of the powerful concepts on which it's built. We'll see how you can provide flexible import routines that allow your module's user to type even less and get code that behaves much more like part of his own program. You can avoid repeating unnecessary parameters to every overly-generic routine and can avoid collision-prone global configuration. All of this is made possible -- and easy -- by Sub::Exporter.
Generators -- routines that build routines -- can produce customized code, built to each importer's specifications. Sub::Exporter lets you build and provide customized routines easily. You'll learn how to write generators, and how to use them with Sub::Exporter . In its simplest form, it's as easy to use as Exporter.pm. With just a bit more configuration, it can build, group, rename, and julienne routines easily. With this tool, you'll be able to provide interfaces that are both simpler and more powerful than those provided by the stock Exporter.
FITC events. For digital creators.
Save 10% off ANY FITC event with discount code 'slideshare'
See our upcoming events at www.fitc.ca
An Intro To ES6
with Grant Skinner
OVERVIEW
ECMAScript 6 is the approved and published standard for the next version of JavaScript. It offers new syntax and language features that provide new ways of tackling coding problems, and increase your productivity.
This session will introduce ES6 and delve into many of the new features of the language. It will also cover real-world use, including transpilers, runtimes, and browser support.
OBJECTIVE
Create confidence in evaluating and getting started using ES6.
TARGET AUDIENCE
JavaScript developers.
ASSUMED AUDIENCE KNOWLEDGE
JavaScript.
FOUR THINGS AUDIENCE MEMBERS WILL LEARN
Status of ES6
How to get started with ES6
ES6 feature overview
Practical considerations for adopting ES6
Выступление в рамках спецкурса "Немейнстримовые технологии разработки", читаемого в НГУ. http://bit.ly/mainstreamless
Аудио дорожка работает, но нужно иметь некоторое терпение, так как грузится она не моментально.
Scalding - Hadoop Word Count in LESS than 70 lines of codeKonrad Malawski
Twitter Scalding is built on top of Cascading, which is built on top of Hadoop. It's basically a very nice to read and extend DSL for writing map reduce jobs.
29. lib2 =
let
l=LetS[ValD(VarP $ mkName"it")(NormalB(f"be"))[]]
f=VarE . mkName
in
DoE [ l, l, l, NoBindS $ f"oh",l,
NoBindS $ InfixE(Just$ f"speaking")(f"words")(Just $ f "wisdom"),l]
30. lib2 =
let
l=LetS[ValD(VarP $ mkName"it")(NormalB(f"be"))[]]
f=VarE . mkName
in
DoE [ l, l, l, NoBindS $ f"oh",l,
NoBindS $ InfixE(Just$ f"speaking")(f"words")(Just $ f "wisdom"),l]
do let it = be
let it = be
let it = be
oh
let it = be
speaking `words` wisdom
let it = be
31. k
GHCi
GHCi> runQ [d| data List a = Cons a (List a) | Nil |]
[DataD [] List [PlainTV a_0] [NormalC Cons [(NotStrict,VarT a_0),
(NotStrict,AppT (ConT List) (VarT a_0))],NormalC Nil []] []]
93. Sum of Product
( )
{-# LANGUAGE Generics, TypeOperators #-}
94. Sum of Product
( )
{-# LANGUAGE Generics, TypeOperators #-}
import GHC.Generics
95. data Bool = False | True
= Unit :+: Unit
data Maybe a = Nothing | Just a
= Unit :+: a
Just 12 = Inr 12, Nothing = Inl Unit
data List a = Nil | Cons a (List a)
= Unit :+: (a :*: (List a))
[1,2,3] = Inr (1 :*: Inr (2 :*:
Inr (3 :*: Inl Unit)))
96. Binary Encode
class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
toBin {| Unit |} Unit = [0]
toBin {| p :*: q |} (a :*: b) = toBin a ++ toBin b
toBin {| p :+: q |} (Inl a) = 0:toBin a
toBin {| p :+: q |} (Inr b) = 1:toBin b
fromBin {| Unit |} (0:xs) = (Unit, xs)
fromBin {| p :*: q |} bin =
let (a, bin') = fromBin bin
(b, bin'') = fromBin bin'
...
97. class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
toBin {| Unit |} Unit = [0]
toBin {| p :*: q |} (a :*: b) = toBin a ++ toBin b
toBin {| p :+: q |} (Inl a) = 0:toBin a
toBin {| p :+: q |} (Inr b) = 1:toBin b
fromBin {| Unit |} (0:xs) = (Unit, xs)
fromBin {| p :*: q |} bin =
let (a, bin') = fromBin bin
(b, bin'') = fromBin bin'
in ...
98. class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
toBin {| Unit |} Unit = [0]
toBin {| p :*: q |} (a :*: b) = toBin a ++ toBin b
toBin {| p :+: q |} (Inl a) = 0:toBin a
toBin {| p :+: q |} (Inr b) = 1:toBin b
fromBin {| Unit |} (0:xs) = (Unit, xs)
fromBin {| p :*: q |} bin =
let (a, bin') = fromBin bin
(b, bin'') = fromBin bin' in (a :*: b, bin’’)
...
99. ( Int, Char) instance
instance Bin Int where
toBin = ....
instance Bin Char where
toBin = ...
instance Bin a Bin [a]
instance (Bin a, Bin b) Bin (a, b)
instance Bin a Bin (Maybe a)
instance (Bin a, Bin b) Bin (Either a b)
107. Typeable / Data
GHC
{-# LANGUAGE DeriveDataTypeable #-}
data Tree a = Leaf a | Branch (Tree a) (Tree a)
deriving (Data, Typeable)
Standalone deriving
{-# LANGUAGE StandaloneDeriving #-}
deriving instance Typeable1 Tree
deriving instance Data a Data (Tree a)
108. --
data Expr = Num Int
| Var String
| Plus Expr Expr
| Minus Expr Expr
| Multi Expr Expr
| Div Expr Expr
deriving (Show, Eq, Data, Typeable)
normalize :: Expr → Expr
normalize = everywhere (mkT normalize')
normalize' (Plus (Num n) (Num m)) = Num (n + m)
normalize' (Multi (Num n) (Num m)) = Num (n * m)
normalize' (Minus (Num n) (Num m)) = Num (n - m)
normalize' (Div (Num n) (Num m)) = Num (n `div` m)
normalize' x =x
115. SYB
mkT :: (b → b) → (a → a)
everywhere :: GenericT → GenericT
116. SYB
mkT :: (b → b) → (a → a)
everywhere :: GenericT → GenericT
bottom-up
117. SYB
mkT :: (b → b) → (a → a)
everywhere :: GenericT → GenericT
bottom-up
top-down everywhere'
118. (1)
GenericT = ∀a. a → a
Transformer
mkT fun
trans `extT` fun
GenericM = ∀a. a → m a :
GenericQ = ∀a. a → r
Query
( ) `mkQ` fun
query `extQ` fun
119. (2)
GenericB = ∀a. a
Builder
builder `extB` fun
GenericR = ∀a. m a
Reader
mkR fun
reader `extR` fun
120. gmapT :: GenericT → a → a
somewhere :: GenericM m → GenecirM m
everything :: (r → r → r) → GenericQ r → GenericQ r
listify :: (r → Bool) → GenericQ [r]
gsize/glength :: GenericQ Int
134. IG
Representable a
type Rep a
data U = U
data a :+: b = L a | R b ( )
data a :*: b = a :*: b
data C con a = C a
data Var p = Var p
data Rec p = Rec p
135. Int, Bool Int, Bool
data Maybe a = Nothing | Just a
type Rep (Maybe a)
= C Maybe_Nothing_ U
:+: C Maybe_Just_ (Var a)
Just 12 = R(C(Var 12)), Nothing = L(C U)
136. Int, Bool Int, Bool
data Maybe a = Nothing | Just a
type Rep (Maybe a)
= C Maybe_Nothing_ U
:+: C Maybe_Just_ (Var a)
Just 12 = R(C(Var 12)), Nothing = L(C U)
137. 1 Binary Encode
class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
C, Var, Rec
instance Bin U where
toBin U = []
fromBin xs = (U, [])
instance (Bin a, Bin b) Bin (a :+: b) where
toBin (L a) = 0:toBin a
toBin (R b) = 1:toBin b
fromBin (0:bin) = ...
...
instance (Bin a, Bin b) Bin (a :*: b) where
toBin (a :*: b) = toBin a ++ toBin b
fromBin bin = ...
instance Bin Int where
...
138. def_toBin :: (Representable a, Bin (Rep a))
a → [Int]
def_toBin = toBin . from
...
instance Bin a Bin [a] where
toBin = def_toBin; fromBin = def_fromBin
139. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)
140. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)
141. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)
142. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)
143. Expr
dft_normalize
:: (Representable a, Normalize (Rep a)) a→a
dft_normalize = to . normalize . from
instance Normalize Expr where
normalize x = case dft_normalize x of
Plus (Num n) (Num m) → Num (n + m)
Multi (Num n) (Num m) → Num (n * m)
Minus (Num n) (Num m) → Num (n - m)
Div (Num n) (Num m) → Num (n `div` m)
x →x
Var Int, Char