Father. Husband. Developer. Microsoft MVP. Likes #fsharp đŚ, #rust đŚ and OSS.
I am pretty excited to announce the re-branding of Minsk F# User Group.
First of all we changed our logo, now it is more “Belarusish”.
Also we’ve prepared a set of wallpapers for F# fans. Feel free to use them to beautify your desktops:
Thanks to EPAM Systems and to all who were involved in preparation of the new logo and wallpapers.
I was looking for examples of Lisp implementations using F# and found these 3 interesting series of blog posts. You can find other posts about implementing Lisp or Scheme using F# but these were the ones I found more comprehensive and different enough to compare different implementations. Although these Lisp implementations are learning experiments and not for production use, itâs fun to see how they are implemented. The series are the following ones:
Tim RobinsonâsLisp Compiler in F#:
Ashley Nathan FenielloâsFScheme series:
View original post 37 more words
Apache Storm is a scalable âstream computingâ platform that is fast gaining popularity. Hadoop and Storm can share the same cluster and the two complement each other well for different computing needs â batch for Hadoop and near-real-time for Storm.
Storm provides a macro architecture for executing âbig dataâ stream processing âtopologiesâ. For example, one easily increase the parallelism of any node in the Storm topology to suit the performance requirements.
For streaming analytics, however, Storm does not offer much help out of the box. Often one has to write the needed analytic logic from scratch. Wouldnât it be nice if one could use something like Reactive Extensions (Rx) within Storm components?
Luckily Nathan Marz â the original author of Storm â chose to enable Storm with multi-language support. While Storm itself is written in Clojure and Java, it implements a (relatively simple?) language-independent protocol that can be used with basicallyâŚ
View original post 292 more words
The absolutely awesome post !!!
This is post #30 of the English 2014 F# advent calendar. Thanks to Sergey Tihon for inviting me and suggesting the topic. Be sure to check out all the other awesome posts!
In this post I will be describing Vagrant, a dependency management library of mine. I will try to walk through some of the subtleties in the .NET framework that drove the library implementation, in an attempt to make it more accessible. All code and examples presented can be found in this repository.
It is often claimed in functional programming that functions are treated as values. This is a valid assumption in simple applications, permitting powerful patterns when writing code. But is this a general truth, or simply a linguistic abstraction? If functions really are values, one would expect that they exhibit all properties normally expected of values. For instance, it should be possible to serialise functionsâŚ
View original post 1,027 more words
Discount code: fshserb (39% off the eBook)
Some days ago, Manning published the final version of a new F# book: “F# Deep Dive“. Â I have read MEAP version of the book, and even had a chance to review the final one.
Book is written by the team of famous F# experts such as: Chris Ballard, Keith Battocchi, Colin Bull, Chao-Jen Chen, Yan Cui, Johann Deneux, Kit Eason, Evelina Gabasova, Dmitry Morozov, Don Syme and composed by Tomas Petricek and Phillip Trelford.
First of all, I want to mention that it is not a usual book about F# or another programming language. If you are novice to F# and looking for a guide of language constructs – this book is not the best choice for you. BUT, Â if you are already familiar with F# basic syntax constructs, can read simple F# code samples and want to see the language in action – this book is for you.
Book is organized as a collection of independent packages written by different authors. Each author tells his own story about F# application to a practical domain, shows how it was used, how it affected an application design and describes why it was done in such a way. Experts show an application of F# to financial and statistical models, internals of Fsharp.Formatting, numerical computing, social networks analysis, real-world usage of type providers, developing MVC application in idiomatic F#, power of F# Async in action, game development, social web apps in F# and many other interesting topics.
One problem with this book, at least for me, that it is difficult to read it cover to cover. Chapters are written by different authors in a different language, sometimes it was hard for me to catch a sense of computation in a completely new domain. So, for all future readers, I recommend to reorganize chapters according to interests and read parts that most valuable for you first.
Finally, I want to say that the book is really good. Everyone will find interesting topics and a new experience. You will get a broader vision of F# application in a real life. You will see how a functional approach can change and simplify the architecture of real life apps. If you are looking for what to read next – take a look at “F# Deep Dives“, this book is really deserves it.
If you want more F# books – visit fsharp.org.
Awesome!
Everyone should read it
Note: This blog post is part of the 2014 F# Advent Calendar. Be sure to check out yesterdayâs Intro to Data Science post by Jon Wood!
If youâve been using F# for any reasonable length of time, youâll have come across the MailboxProcessor, AKA the F# Agent (or Actor). Mailbox Processors are cool. They give us the ability to offload load to background processors without worrying about managing the thread that they live on (as agents silently âgo to sleepâ when they arenât processing anything), and they take away the pain of locking as they ensure that only one message will be processed at a time whilst automatically queuing up backed up messages. They also allow us to visualise problems differently to how we might do so when just using a raw Task, in terms of message passing. We can partition data based by pushing themâŚ
View original post 2,631 more words
Update: Event extended until December 31.
Our friends from Japan have a beautiful event called “F# Advent Calendar“. Every day from December 1 to December 31, one awesome volunteer publish a new post about F#. What an amazing way to celebrate Christmas, isn’t it?
Lets support this initiative and do an English version of the calendar. Two blog posts per day is better than one, isn’t it? We need 31 volunteers, who are ready to prepare a post about F# and publish it on specified date.
Rules
Rules are very simple:
Calendar
Script for this article is available as public Gist.
For a long time I was interested in what is going on on NuGet. I think that NuGet UI does not provide one important piece of information – which packages depend on current packages. This information is very useful for package authors and also can help a user to find packages that provide more sophisticated implementation.
Other interesting thing is to see the big picture and answer some global questions:
I believe that there are a lot of other answers we can find from the high view.
Some time ago I have found that NuGet team provides NuGet.Core package that has all  API required to communicate with NuGet. The API is not really fast if you are going to download information about all versions of all NuGet packages đ But NuGet team is working on a new v3 API that is going to be much faster than current v2. For current research I have downloaded info about all packages and all their versions to my FSI session to be able to run different types of analysis and create visualizations without further communication with NuGet. This operation is slow enough: it took about 1 hour last time when I run it, but it really depends on NuGet workload and your internet connection.
The second thing is visualization of the result, here I want to say thank you to Scott Wlaschin for his great script type-dependency-graph.fsx (that was built for ‘Cycles and modularity in the wild‘ analysis). I took his GraphViz module and slightly modified it to allow colorful graphs printing. To use it you need to download GraphViz from the official site.
That is all tooling that we need. So we are ready to describe a structure of an analysis – script extracts 3 subsets of NuGet packages and visualizes them in different colors with all dependencies.
NOTE: In this analysis I ignored package version and considered only latest package version and dependencies of latest version. If you need more accurate analysis you should adjust script a bit.
Running this script I did some interesting observations:
I hope that you’ll also find this script useful and discover something interesting on NuGet.
