mbrace.io Open in urlscan Pro
192.30.252.154  Public Scan

Form analysis
0 forms found in the DOM

Text Content

MBrace.Core on github • MBrace.Azure on github • MBrace.AWS on github

 * TRY get started
   * Try MBrace.Core (locally simulated)
   * Try MBrace.Azure (Azure-hosted)
   * Contribute to MBrace.AWS (Amazon-hosted)
 * FEATURES details
 * CONTRIBUTE open source
   * Become a contributor
   * 
   * Report an Issue (MBrace.Core)
   * Roadmap (MBrace.Core)
   * Contribute (MBrace.Core)
   * 
   * Report an Issue (MBrace.Azure)
   * Roadmap (MBrace.Azure)
   * Contribute (MBrace.Azure)
   * 
   * Report an Issue (MBrace.AWS)
   * Contribute (MBrace.AWS)
 * SUPPORT training
 * DOCUMENTATION tutorials, reference
   * Programming Model
   * 
   * Getting Started (Locally Simulated)
   * Getting Started (Azure)
   * 
   * API Reference (Core)
   * API Reference (Azure)
   * API Reference (AWS)
   * API Reference (Client)
 * VIDEOS & ARTICLESwatch and learn
   * Videos and Articles
   * 
   * PLOS Paper
   * 
   * Implementation of MBrace

Get Started Now


INTEGRATED DATA SCRIPTING FOR THE CLOUD - GET STARTED WITH MBRACE TODAY.


WELCOME TO MBRACE SIMPLE SCRIPTING OF SCALABLE COMPUTE AND DATA JOBS PROGRAMMING
MODEL INDEPENDENT OF CLOUD VENDOR BIG DATA AND BIG COMPUTE MBRACE

MBrace.Core is a simple programming model for scalable cloud data scripting and
programming with F# and C#. With MBrace.Azure, you can script Azure for
large-scale compute and data processing, directly from your favourite editor.

SIMPLE CLOUD PROGRAMMING

MBrace.Core is a cloud programming model simple enough to be explained on a
single slide.

AZURE SUPPORT

MBrace.Azure implements MBrace.Core on the Azure cloud platform.

SIMPLE PROVISIONING

Simple cluster provisioning for Azure.

SCRIPTING FOR COMPUTE AND DATA

Integrate cloud-scale compute and data processing directly into your F#/C#
scripting.

BIG DATA, BIG COMPUTE

Scale your data scripts across tens to thousands of machines with seamless
access to cloud storage.

DIRECT FROM YOUR EDITOR

With MBrace.Azure, use your Azure storage and compute assets, at your fingertips
in your favourite editor.


GETTING STARTED WITH MBRACE.CORE

 1. Learn basic F# scripting in your favourite editor
 2. Create and use a simulated cluster and storage on your local machine


GETTING STARTED WITH MBRACE.AZURE

 1. Learn basic F# scripting in your editor
 2. Create and use an MBrace cluster in Azure, with highly scalable storage and
    compute


CONTRIBUTE TO MBRACE.AWS

 1. Work is underway to map the MBrace.Core programming model to Amazon Web
    Services too!
 2. Follow and contribute to this work on github.


TRAINING AND SUPPORT

Consultancy partners including Nessos and Compositional IT contribute to MBrace
and provide training, support and consultancy services.

Combining the strength and experience of two consultancies, Nessos and
Compositional IT partner to bring you training and support for both MBrace.Core
and MBrace.Azure.





MBRACE.CORE - CLOUD PROGRAMMING MADE SIMPLE

Confused by the cloud? Cloud computation and data can be simple, if using the
right framework. MBrace.Core helps the cloud empower you, not enslave you.


 * Cloud Workflows
 * Concurrent
 * Fault Tolerant
 * High Availability

 * Functional Cloud Data Flows
 * Partitioned Cloud Vectors
 * Abstract and Reuse Common Cloud Patterns
 * Strong Typing For Cloud Data

 * Full F# and C# Support
 * Cloud Vendor Neutral
 * 100% Open Source
 * Extensible Data Serialization

MBrace.Core is an open source software framework, initiated by experts, for
developing big data algorithms that will execute on a private or public cloud.
It is similar to Hadoop but simpler, explorative and not confined to the
map-reduce paradigm.

MBrace.Core abstracts the underlying cloud infrastructure - code developed using
MBrace.Core can run locally or on a supported private or public clouds.

MBrace.Core integrates with F# Interactive where you can delve into REPL style
programming which enables fast code prototyping in a cloud scale, job monitoring
and code deployment.


MBRACE.AZURE - INCLUDED FEATURES

Whether new to Azure or an advanced Azure developer, MBrace.Azure brings Azure
storage and compute to your fingertips.


 * Cloud Scripting from Your Editor
 * Programmatic Data Upload
 * Automatic Code Transport
 * Extensible Data Serialization
 * Fault Tolerance Options

 * Full F# and C# Support
 * Job Creation and Control
 * Integrated Cloud Logging
 * Smooth Transitions From Scripts to Code
 * Nuget Packages

 * All MBrace.Core Features
 * Interoperate With Azure Services
 * Local Prototyping
 * Native CPU Performance
 * 100% Open Source

MBrace.Azure takes care of task orchestration and data flow between your
scripting environment and worker nodes: you deal with the data and algorithm you
want to execute.

MBrace.Azure uses Azure storage and Azure Service Bus. Azure geo-replication and
Premium storage options give additional storage safety and performance.

The MBrace.Azure runtime makes executing processes fault tolerant. If the
underlying platform resources fail, e.g. a security patch is applied abruptly,
the computations are either already replicated over different nodes, or they
will be restarted.


RUN SCALABLE, DISTRIBUTED DATA PARALLEL WORKFLOWS IN THE CLOUD

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 


open MBrace.Core
open MBrace.Flow

let numberOfDuplicates =
    CloudFlow.OfCloudFilesByLine ["container/data0.csv" ; "container/data1.csv"]
    |> CloudFlow.map (fun line -> line.Split(','))
    |> CloudFlow.map (fun tokens -> int tokens.[0], Array.map int tokens.[1 ..])
    |> CloudFlow.groupBy (fun (id,_) -> id)
    |> CloudFlow.filter (fun (_,values) -> Seq.length values > 1)
    |> CloudFlow.length
    |> cluster.Run


val cluster : MBrace.Azure.Runtime

Full name: Snippets-index.cluster
module Unchecked

from FSharp.Core.Operators
val defaultof<'T> : 'T

Full name: FSharp.Core.Operators.Unchecked.defaultof
namespace MBrace.Core
type Runtime =
  private new : clientId:string * config:Configuration -> Runtime
  member AttachClientLogger : logger:ICloudLogger -> unit
  member AttachLocalWorker : ?workerCount:int * ?maxTasks:int -> unit
  member ClearAllProcesses : ?fullClear:bool * ?force:bool -> unit
  member ClearAllProcessesAsync : ?fullClear:bool * ?force:bool -> Async<unit>
  member ClearProcess : pid:string * ?fullClear:bool * ?force:bool -> unit
  member ClearProcessAsync : pid:string * ?fullClear:bool * ?force:bool ->
Async<unit>
  member CreateCancellationTokenSource : unit -> ICloudCancellationTokenSource
  member CreateProcess : workflow:Cloud<'T> * ?name:string *
?defaultDirectory:string * ?fileStore:ICloudFileStore *
?defaultAtomContainer:string * ?atomProvider:ICloudAtomProvider *
?defaultChannelContainer:string * ?channelProvider:ICloudChannelProvider *
?dictionaryProvider:ICloudDictionaryProvider *
?cancellationToken:ICloudCancellationToken * ?faultPolicy:FaultPolicy ->
Process<'T>
  member CreateProcessAsTask : workflow:Cloud<'T> * ?name:string *
?defaultDirectory:string * ?fileStore:ICloudFileStore *
?defaultAtomContainer:string * ?atomProvider:ICloudAtomProvider *
?defaultChannelContainer:string * ?channelProvider:ICloudChannelProvider *
?dictionaryProvider:ICloudDictionaryProvider *
?cancellationToken:ICloudCancellationToken * ?faultPolicy:FaultPolicy ->
Task<Process<'T>>
  ...

Full name: MBrace.Azure.Runtime
namespace MBrace.Core
namespace MBrace.Flow
val numberOfDuplicates : int64

Full name: Snippets-index.numberOfDuplicates
static member CloudFlow.OfCloudFilesByLine : paths:seq<string> *
?encoding:System.Text.Encoding * ?sizeThresholdPerCore:int64 ->
CloudFlow<string>
val map : f:('T -> 'R) -> flow:CloudFlow<'T> -> CloudFlow<'R>

Full name: MBrace.Flow.CloudFlow.map
val line : string
System.String.Split(params separator: char []) : string []
System.String.Split(separator: string [], options: System.StringSplitOptions) :
string []
System.String.Split(separator: char [], options: System.StringSplitOptions) :
string []
System.String.Split(separator: char [], count: int) : string []
System.String.Split(separator: string [], count: int, options:
System.StringSplitOptions) : string []
System.String.Split(separator: char [], count: int, options:
System.StringSplitOptions) : string []
val tokens : string []
Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: FSharp.Core.Operators.int

--------------------
type int = int32

Full name: FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: FSharp.Core.int<_>
module Array

from FSharp.Collections
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []

Full name: FSharp.Collections.Array.map
val groupBy : projection:('T -> 'Key) -> source:CloudFlow<'T> -> CloudFlow<'Key
* seq<'T>> (requires equality)

Full name: MBrace.Flow.CloudFlow.groupBy
val id : int
val filter : predicate:('T -> bool) -> flow:CloudFlow<'T> -> CloudFlow<'T>

Full name: MBrace.Flow.CloudFlow.filter
val values : seq<int * int []>
module Seq

from FSharp.Collections
val length : source:seq<'T> -> int

Full name: FSharp.Collections.Seq.length
val length : flow:CloudFlow<'T> -> Cloud<int64>

Full name: MBrace.Flow.CloudFlow.length


VIDEOS AND ARTICLES

MBRACE: REPL-DRIVEN SCALABLE COMPUTATION EIRIK TSARPALIS

NYC F#

CRUNCHING THROUGH BIG DATA WITH MBRACE, AZURE AND F# MATHIAS BRANDEWINDER

MVP Summit 2015

MBRACE: HARNESSING THE CLOUD WITH .NET NICK PALLADINOS

Skillsmatter, London

F# AND MBRACE WITH LENA DZENISENKA CHANNEL 9

.NET Fringe, Portland

THE F# PATH TO DATA SCRIPTING NIRVANA TOMAS PETRICEK, ISAAC ABRAHAM, DON SYME

dotnetConf

BIGDEEDLE - MBRACE AND DEEDLE FOR VERY LARGE TIME SERIES AND DATA FRAMES. TOMAS
PETRICEK

GitHub


MBRACE.AZURE BRINGS AZURE SCALABILITY DIRECT TO YOUR FAVOURITE EDITOR

> MBrace.Azure integrates Azure storage and compute VMs as a kind of
> co-processor to your F# Interactive scripting sessions or your F#/C#
> applications. It brings Azure scalability directly into your favourite editor
> using an intuitive and powerful data scripting model. Combining MBrace.Azure
> with F# gives a powerful and scalable cloud data scripting solution. Don Syme,
> F# Language Designer




SCALING OUT LEGACY SOFTWARE

MBrace proved to be one of the most valuable tools we 've ever used; it managed
to scale our flagship application ThermoS (a FORTRAN based legacy application)
to the cloud, orchestrating a multitude of parametric executions and gathering
all of the data produced, without altering a single line of code in ThermoS! The
combination of Azure and MBrace coupled with ThermoS provided us with the
necessary capacity for our clients' growing needs while keeping the costs at an
absolute minimum.

Panos Theodossopoulos, CEO Propulsion Analytics


DISTRIBUTING MACHINE LEARNING TASKS

I was amazed by the simplicity of MBrace and how quickly we could go from
starting out for the first time to running compute tasks on a cluster of 150
instances, all from your favourite editor! Machine learning tasks often require
cleaning up the dataset before being able to run any training on them. These
clean up tasks could take a lot of time. In our case it was finding and removing
duplicate images irrespective of their scale, resolution or crop. By using
MBrace's easy compute distribution we could quickly try out our ideas and get
results

Indeera, Machine Learning Software Developer


INTENSE BIG DATA PROCESSING

I am using MBrace with great pleasure for distributed data science and analysis
tasks, possible to run even in exploratory way as an interactive scripts
directly from FSI. It is awesome to use for large input data sets, big data
processing and any intense algorithms that can be distributed. MBrace managed to
build a super friendly infrastructure with absolutely simple and fast cloud
provisioning using Azure. One of the most valuable advantages of MBrace is the
ability to define algorithmic patterns of distribution on the library level
instead of internal runtime ecosystem. MBrace respects the efforts and helps to
maximize productivity.

Alena Dzenisenka, Software Architect, Member of FSSF Board Of Trustees


WORK WITH LEGACY CODE, EASIER PARALLELISM

The combination of F# and MBrace provides great simplicity in programming the
distributed cloud environment. I have a lot of code performing program analysis
originally written in C# and I used Azure virtual machine and worker roles to do
the parallelism. Now I started to use MBrace and am quite happy about it: (1) it
is very easy to include my C# code along with many dependencies in the MBrace
framework; (2) the parallelism is so much easier to control and change. (3) the
scripting-style MBrace environment provides instant feedback on the parallel
jobs, this greatly increases my productivity in data exploration.

Yi Wei, Research Engineer, Microsoft Research Cambridge


SCALABLE BIOLOGICAL COMPUTATION MODELLING

MBrace substantially reduces the effort of running our large-scale numeric and
symbolic computations on flexible infrastructure. With the documented examples
and only a few hours effort, I adapted one of our molecular computing tools from
our 10+ year codebase (F#, C#, C++) to having a working sample on MBrace and
Azure. MBrace has allowed us to easily move our command-line tools from fixed
compute clusters to Azure allowing us to scale on demand. Even better, it lets
us specify the experiments dynamically from F# interactive.

Colin Gravill, Software Developer, Biological Computation, Microsoft Research


CONTRIBUTE TO MBRACE!

MBrace.Core and MBrace.Azure are both fully open source under an Apache 2.0
license. You can contribute to them today.

Join the MBrace team. See our roadmap and development guide for ways to
contribute.

MBrace on GitHub


BECOME AN MBRACE CONTRIBUTOR TODAY!

EIRIK TSARPALIS CORE TEAM



Eirik is F# developer and mathematician at Nessos.

NICK PALLADINOS CORE TEAM



Nick is lead software designer and researcher at Nessos.

KOSTAS RONTOGIANNIS CORE TEAM



Kostas is F# Developer and Azure specialist at Nessos.

ISAAC ABRAHAM AZURE EXPERT, COMPOSITIONAL IT



F# MVP, Azure consultant, director of Compositional IT and author of Learn F#.

YAN CUI MBRACE.AWS



F# Developer and AWS Specialist.

DON SYME F# LANGUAGE DESIGNER (ADVISOR)



F# Language Designer, MBrace Design Advisor.

ABOUT US

MBrace.Core and MBrace.Azure are open source projects supported by an open
community of contributors including Nessos and Compositional IT.

JOIN US ON GITHUB TODAY

--------------------------------------------------------------------------------