"Scala enables you to define a new construct that lies halfway between an interface and a class, called a trait. Traits are unusual in that a class can incorporate as many of them as desired, like interfaces, but they can also contain behavior, like classes. Also, like both classes and interfaces, traits can introduce new methods. But unlike either, the definition of that behavior isn't checked until the trait is actually incorporated as part of a class. Or, put differently, you can define methods that aren't checked for correctness until they're incorporated into a trait-using class definition.
Traits may sound complex, but they're easier understood once you've seen them in action. To get started, here's the Person POJO redefined in Scala:"
" a thoughtless eventing setup leads to bad control flow issues. In the case of Mixpanel, as some of our front-end reports grew in scope and complexity, patterns which worked at first became unwieldy"
"I started applying React to a tool I built called RxMarbles.com, and spent some time investigating Flux. React turned out to disappoint me in multiple ways, mainly through a poorly designed API which induces the programmer to create complex state machines and to mix multiple concerns in one component. I decided to replace React with the great virtual-dom library, and to build a Reactive MVC alternative heavily based on RxJS. This pattern turned out to be successful and I applied it to other web apps. One of these is a customer project we are glad to say has worked out very well.
The combo React/Flux is clearly inspired by Reactive Programming principles, but the API and architecture are an unjustified mix of Interactive and Reactive patterns. Keep reading and I'll explain what this means, and how we can do better."
"A Support Vector Machine (SVM) is a discriminative classifier formally defined by a separating hyperplane. In other words, given labeled training data (supervised learning), the algorithm outputs an optimal hyperplane which categorizes new examples."
Best practices for Scala at Twitter.
"Finally, some pithy rules
1. Introduce abstraction when it increases
precision; when it serves to clarify.
2. Brevity is not the goal; clarity is.
3. Rich data structures are overrated.
4. Consistency, familiarity, and predictability are the
most important traits of code. Have empathy for
5. Write books; not poems."
"The selection of the appropriate distribution depends on the presence or absence of symmetry of the data set with respect to the mean value.
When the data are symmetrically distributed around the mean while the frequency of occurrence of data farther away from the mean diminishes, one may for example select the normal distribution, the logistic distribution, or the Student's t-distribution. The first two are very similar, while the last, with one degree of freedom, has "heavier tails" meaning that the values farther away from the mean occur relatively more often (i.e. the kurtosis is higher). The Cauchy distribution is also symmetric.
Skew distributions to the right
When the larger values tend to be farther away from the mean than the smaller values, one has a skew distribution to the right (i.e. there is positive skewness), one may for example select the log-normal distribution (i.e. the log values of the data are normally distributed), the log-logistic distribution (i.e. the log values of the data follow a logistic distribution), the Gumbel distribution, the exponential distribution, the Pareto distribution, the Weibull distribution, or the Fréchet distribution. The last three distributions are bounded to the left.
Skew distributions to the left
When the smaller values tend to be farther away from the mean than the larger values, one has a skew distribution to the left (i.e. there is negative skewness), one may for example select the square-normal distribution (i.e. the normal distribution applied to the square of the data values), the inverted (mirrored) Gumbel distribution, or the Gompertz distribution, which is bounded to the left.
"People often talk about different types of tests, but it seems to be a bit hard to keep track of what each type of tests is supposed to do. I decided to create a short guide from a web developer’s perspective.
The confusing part is that people often mix two different things. One is testing level and the other is testing type. Another important thing is that you shouldn’t assume we talk about writing automated tests here. Clicking inside a browser manually is also considered testing. Let’s talk about testing levels first."
"Mosaic plot is a graphical method for visualizing data from two or more qualitative variables. It is the multidimensional extension of spineplots, which graphically display the same information for only one variable. It gives an overview of the data and makes it possible to recognize relationships between different variables. For example, Independence is shown when the boxes across categories all have the same areas."
"This pattern can be used to solve Ted Neward's problem, and most problems where you would otherwise use type tokens but you need to support generic types as well as reifiable types. Although this isn't much more than a generic factory interface, the automatic hook into the rich generic reflection system is more than you can get with simple class literals. With a few more bells and whistles (toString, hashCode, equals, etc) I think this is a worthy candidate for inclusion in the JDK."
"I think many people find type classes to be a stumbling block as they join the Scala community, in part because of what appears to be magic brought about by implicits and in part because there’s often no mention of how they fit into their existing toolbox. Hopefully this helps to demystify them a little bit; mechanically they’re like Strategies but with more of a focus on declaring a capability (and the operations which go along with that capability) than on extracting the underlying algorithm, with a little bit of implicit pixie dust to help keep the code clean."
SAML 2.0 specifies a Web Browser SSO Profile involving an identity provider (IdP), a service provider (SP), and a principal wielding an HTTP user agent. The SP has four bindings from which to choose while the IdP has three, which leads to twelve (12) possible deployment scenarios. We outline two such deployment scenarios below.
"In this blog post:
Why install Shibboleth on Amazon EC2 instance (or private cloud)
Securing application deployed to PaaS with Shibboleth SP
Resolving security concern of the cloud deployment with HTTPS and Private key encryption.
Code samples in Java and Groovy for securing REST API"