Muutke küpsiste eelistusi

E-raamat: Expert F# 4.0

3.97/5 (52 hinnangut Goodreads-ist)
, ,
  • Formaat: PDF+DRM
  • Ilmumisaeg: 31-Dec-2015
  • Kirjastus: APress
  • Keel: eng
  • ISBN-13: 9781484207406
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 86,44 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Expert F# 4.0Suurem pilt
  • Formaat: PDF+DRM
  • Ilmumisaeg: 31-Dec-2015
  • Kirjastus: APress
  • Keel: eng
  • ISBN-13: 9781484207406
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Learn from F#'s inventor to become an expert in the latest version of this powerful programming language so you can seamlessly integrate functional, imperative, object-oriented, and query programming style flexibly and elegantly to solve any programming problem. Expert F# 4.0 will help you achieve unrivaled levels of programmer productivity and program clarity across multiple platforms including Windows, Linux, Android, OSX, and iOS as well as HTML5 and GPUs.

F# 4.0 is a mature, open source, cross-platform, functional-first programming language which empowers users and organizations to tackle complex computing problems with simple, maintainable, and robust code.

Expert F# 4.0 is:

  • A comprehensive guide to the latest version of F# by the inventor of the language
  • A treasury of F# techniques for practical problem-solving
  • An in-depth case book of F# applications and F# 4.0 concepts, syntax, and features

Written by F#'s inventor and two major F# community members, Expert F# 4.0 is a comprehensive and in-depth guide to the language and its use. Designed to help others become experts, the book quickly yet carefully describes the paradigms supported by F# language, and then shows how to use F# elegantly for a practical web, data, parallel and analytical programming tasks.

The world's experts in F# show you how to program in F# the way they do!



About the Authors xxiii
About the Technical Reviewers xxv
Acknowledgments xxvii
Chapter 1 Introduction
1(6)
The Genesis of F#
2(1)
About This Book
2(3)
Who This Book Is For
5(2)
Chapter 2 Your First F# Program: Getting Started with F#
7(22)
Creating Your First F# Program
7(2)
Documenting Code
9(1)
Using let
9(1)
Understanding Types
10(2)
Calling Functions
12(1)
Lightweight Syntax
12(1)
Understanding Scope
13(1)
Using Data Structures
14(1)
Using Properties and the Dot-Notation
15(1)
Using Tuples
16(2)
Using Imperative Code
18(1)
Using Object-Oriented Libraries from F#
19(1)
Using open to Access Namespaces and Modules
20(1)
Fetching a Web Page
21(2)
Getting and Using Packages
23(1)
Accessing External Data Using F# Packages
24(1)
Starting a Web Server and Serving Data using F# Packages
25(2)
Summary
27(2)
Chapter 3 Introducing Functional Programming
29(26)
Starting with Numbers and Strings
29(1)
Some Simple Types and Literals
29(2)
Arithmetic Conversions
31(1)
Arithmetic Comparisons
31(1)
Simple Strings
31(1)
Working with Conditionals: && and II
32(1)
Defining Recursive Functions
33(1)
Lists
34(4)
Options
38(1)
Getting Started with Pattern Matching
39(1)
Matching on Structured Values
40(1)
Guarding Rules and Combining Patterns
41(1)
Further Ways of Forming Patterns
42(1)
Introducing Function Values
43(1)
Using Function Values
44(1)
Computing with Collection Functions
44(1)
Using Fluent Notation on Collections
45(1)
Composing Functions with >>
46(1)
Building Functions with Partial Application
47(1)
Using Local Functions
48(1)
Iterating with Functions
49(1)
Abstracting Control with Functions
50(1)
Using Object Methods as First-Class Functions
51(1)
Some Common Uses of Function Values
51(2)
Summary
53(2)
Chapter 4 Introducing Imperative Programming
55(34)
About Functional and Imperative Programming
55(1)
Imperative Looping and Iterating
56(1)
Simple for Loops
56(1)
Simple While Loops
57(1)
More Iteration Loops over Sequences
57(1)
Using Mutable Records
58(1)
Avoiding Aliasing
59(1)
Using Mutable let Bindings
60(1)
Hiding Mutable Data
61(1)
Working with Arrays
62(2)
Generating and Slicing Arrays
64(1)
Two-Dimensional Arrays
65(1)
Introducing the Imperative .NET Collections
65(1)
Using Resizable Arrays
65(1)
Using Dictionaries
66(1)
Using Dictionary's TryGetValue
67(1)
Using Dictionaries with Compound Keys
68(1)
Some Other Mutable Data Structures
69(1)
Exceptions and Controlling Them
69(2)
Catching Exceptions
71(1)
Using try . . . finally
72(1)
Defining New Exception Types
72(1)
Having an Effect: Basic I/O
73(1)
.NET I/O via Streams
74(2)
Some Other I/O-Related Types
76(1)
Using System.Console
76(1)
Combining Functional and Imperative Efficient Precomputation and Caching
76(1)
Precomputation and Partial Application
77(1)
Precomputation and Objects
78(1)
Memoizing Computations
79(3)
Lazy Values
82(1)
Other Variations on Caching and Memoization
83(1)
Mutable Reference Cells
83(1)
Combining Functional and Imperative: Functional Programming with Side Effects
84(1)
Consider Replacing Mutable Locals and Loops with Recursion
84(1)
Separating Pure Computation from Side-Effecting Computations
85(1)
Separating Mutable Data Structures
85(1)
Not All Side Effects Are Equal
86(1)
Avoid Combining Imperative Programming and Laziness
87(1)
Summary
88(1)
Chapter 5 Understanding Types in Functional Programming
89(32)
Exploring Some Simple Type Definitions
89(1)
Defining Type Abbreviations
89(1)
Defining Record Types
90(1)
Handling Non-Unique Record Field Names
91(1)
Cloning Records
92(1)
Defining Discriminated Unions
92(2)
Using Discriminated Unions as Records
94(1)
Defining Multiple Types Simultaneously
95(1)
Understanding Generics
95(1)
Writing Generic Functions
96(1)
Some Important Generic Functions
97(6)
Making Things Generic
103(1)
Generic Algorithms through Explicit Arguments
103(1)
Generic Algorithms through Function Parameters
104(2)
Generic Algorithms through Inlining
106(2)
More on Different Kinds of Types
108(1)
Reference Types and Value Types
108(1)
Other Flavors of .NET Types
109(1)
Understanding Subtyping
109(1)
Casting Up Statically
110(1)
Casting Down Dynamically
110(1)
Performing Type Tests via Pattern Matching
111(1)
Knowing When Upcasts Are Applied Automatically
111(2)
Flexible Types
113(1)
Troubleshooting Type-Inference Problems
114(1)
Using a Visual Editing Environment
114(1)
Using Type Annotations
114(1)
Understanding the Value Restriction
115(1)
Working Around the Value Restriction
116(2)
Understanding Generic Overloaded Operators
118(1)
Summary
119(2)
Chapter 6 Programming with Objects
121(40)
Getting Started with Objects and Members
121(4)
Using Classes
125(3)
Adding Further Object Notation to Your Types
128(1)
Working with Indexer Properties
128(1)
Adding Overloaded Operators
129(1)
Using Named and Optional Arguments
130(2)
Adding Method Overloading
132(1)
Defining Object Types with Mutable State
133(2)
Using Optional Property Settings
135(1)
Declaring Auto-Properties
136(1)
Getting Started with Object Interface Types
136(2)
Defining New Object Interface Types
138(1)
Implementing Object Interface Types Using Object Expressions
138(2)
Implementing Object Interface Types Using Concrete Types
140(1)
Using Common Object Interface Types from the .NET Libraries
141(1)
Understanding Hierarchies of Object Interface Types
142(1)
More Techniques for Implementing Objects
142(1)
Combining Object Expressions and Function Parameters
142(2)
Defining Partially Implemented Class Types
144(1)
Using Partially Implemented Types via Delegation
145(1)
Using Partially Implemented Types via Implementation Inheritance
145(2)
Combining Functional and Objects: Cleaning Up Resources
147(1)
Resources and IDisposable
147(3)
Managing Resources with More-Complex Lifetimes
150(1)
Cleaning Up Internal Objects
150(1)
Cleaning Up Unmanaged Objects
151(2)
Extending Existing Types and Modules
153(3)
Working with F# Objects and .NET Types
156(1)
Structs
157(1)
Delegates
158(1)
Enums
158(1)
Working with null Values
159(1)
Summary
160(1)
Chapter 7 Encapsulating and Organizing Your Code
161(20)
Hiding Things
161(1)
Hiding Things with Local Definitions
162(2)
Hiding Things with Accessibility Annotations
164(3)
Organizing Code with Namespaces and Modules
167(1)
Putting Your Code in a Module
167(1)
Putting Your Modules and Types in Namespaces
168(1)
Defining a Module with the Same Name as a Type
169(1)
Preventing Client Code from Opening a Module
169(1)
Using Files as Modules
170(1)
Automatically Opening Modules
170(1)
Projects, Assemblies, and Compilation Order
171(1)
Creating Assemblies, DLLs, and EXEs
171(3)
Project Files and Compilation Order
174(2)
Using Signature Files
176(2)
Designing with Signatures
178(1)
When Are Signature Types Checked?
178(1)
Reusing Your Code
178(1)
Using Files as Small Reusable Components
178(1)
Creating and Sharing Packages
179(1)
Summary
179(2)
Chapter 8 Working with Textual Data
181(32)
Building Strings and Formatting Data
181(1)
Building Strings
181(1)
More about String Literals
182(1)
Using printf and Friends
183(2)
Generic Structural Formatting
185(1)
Formatting Strings Using .NET Formatting
185(1)
Parsing Strings and Textual Data
186(1)
Parsing Basic Values
186(1)
Processing Line-Based Input
187(1)
Using Regular Expressions
188(1)
More on Matching with System.Text.RegularExpressions
189(4)
More Robust Code with the Regular Expression Type Provider
193(1)
Using XML as a Concrete Language Format
194(1)
Using the System.Xml Namespace
195(2)
From Concrete XML to Abstract Syntax
197(2)
Using the FSharp.Data XmlTypeProvider
199(3)
Using JSON as a Concrete Language Format
202(1)
Parsing JSON Data
202(1)
Using the FSharp.Data JsonProvider
203(2)
Some Recursive Descent Parsing
205(1)
A Simple Tokenizer
205(1)
Recursive-Descent Parsing
206(2)
Binary Parsing and Formatting
208(3)
Encoding and Decoding Unicode Strings
211(1)
Encoding and Decoding Binary Data
212(1)
Summary
212(1)
Chapter 9 Working with Sequences and Tree-Structured Data
213(44)
Getting Started with Sequences
213(1)
Using Range Expressions
214(1)
Iterating a Sequence
215(1)
Transforming Sequences with Functions
215(1)
Which Types Can Be Used as Sequences?
216(1)
Using Lazy Sequences from External Sources
217(1)
Using Sequence Expressions
218(1)
Enriching Sequence Expressions with Additional Logic
219(1)
Generating Lists and Arrays Using Sequence Expressions
220(1)
More on Working with Sequences
220(1)
Using Other Sequence Operators: Truncate and Sort
221(1)
Selecting Multiple Elements from Sequences
222(2)
Finding Elements and Indexes in Sequences
224(1)
Grouping and Indexing Sequences
224(1)
Folding Sequences
225(2)
Cleaning Up in Sequence Expressions
227(1)
Expressing Operations Using Sequence Expressions
227(1)
Structure beyond Sequences: Domain Modeling
228(2)
Transforming Domain Models
230(1)
Using On-Demand Computation with Domain Models
231(2)
Caching Properties in Domain Models
233(1)
Memoizing Construction of Domain Model Nodes
234(2)
Active Patterns: Views for Structured Data
236(1)
Converting the Same Data to Many Views
236(2)
Matching on .NET Object Types
238(1)
Defining Partial and Parameterized Active Patterns
239(1)
Hiding Representations with Active Patterns
240(2)
Equality, Hashing, and Comparison
242(1)
Asserting Equality, Hashing, and Comparison Using Attributes
243(1)
Fully Customizing Equality, Hashing, and Comparison on a Type
244(2)
Suppressing Equality, Hashing, and Comparison on a Type
246(1)
Customizing Generic Collection Types
246(1)
Tail Calls and Recursive Programming
247(1)
Tail Recursion and List Processing
248(2)
Tail Recursion and Object-Oriented Programming
250(1)
Tail Recursion and Processing Unbalanced Trees
251(1)
Using Continuations to Avoid Stack Overflows
252(2)
Another Example: Processing Syntax Trees
254(1)
Summary
255(2)
Chapter 10 Numeric Programming and Charting
257(28)
Getting Started with FsLab
257(1)
Basic Charting with FSharp.Charting
258(1)
Basic Numeric Types and Literals
259(1)
Arithmetic Operators
260(1)
Checked Arithmetic
261(1)
Arithmetic Conversions
261(1)
Arithmetic Comparisons
262(1)
Overloaded Math Functions
262(1)
Bitwise Operations
262(1)
Sequences, Statistics, and Numeric Code
263(1)
Summing, Averaging, Maximizing, and Minimizing Sequences
263(3)
Counting and Categorizing
266(1)
Writing Fresh Numeric Code
266(2)
Making Numeric Code Generic
268(1)
Example: KMeans
269(2)
Statistics, Linear Algebra, and Distributions with Math.NET
271(1)
Basic Statistical Functions in Math.NET Numerics
272(1)
Using Histograms and Distributions from Math.NET Numerics
273(1)
Using Matrices and Vectors from Math.NET
274(1)
Matrix Inverses, Decomposition, and Eigenvalues
275(1)
Time Series and Data Frames with Deedle
276(3)
Units of Measure
279(1)
Adding Units to a Numeric Algorithms
280(2)
Adding Units to a Type Definition
282(1)
Applying and Removing Units
283(1)
Some Limitations of Units of Measure
283(1)
Summary
284(1)
Chapter 11 Reactive, Asynchronous, and Parallel Programming
285(32)
Introducing Terminology
286(1)
Events
287(1)
Creating and Publishing Events
288(1)
Events as First-Class Values
289(1)
From Events to Observables
290(1)
Asynchronous Computations
290(1)
Fetching Multiple Web Pages in Parallel, Asynchronously
290(2)
Understanding Asynchronous Computations
292(3)
Example: Parallel File Processing Using Async Computations
295(3)
Running Async Computations
298(1)
Common I/O Operations in Asynchronous Computations
298(1)
Understanding Exceptions and Cancellations
299(1)
Interoperating with .NET Tasks
300(1)
Agents
301(1)
Introducing Agents
301(2)
Creating Objects That React to Messages
303(2)
Scanning Mailboxes for Relevant Messages
305(1)
Example: An Asynchronous Agent for Web Crawling
306(3)
Example: Using async for CPU Parallelism
309(1)
Under the Hood: Implementing Async.Parallel
310(1)
Using Shared-Memory Concurrency
310(1)
Creating Threads Explicitly
311(1)
Creating Tasks Explicitly
311(1)
Shared Memory, Race Conditions, and the .NET Memory Model
312(1)
Using Locks to Avoid Race Conditions
313(1)
Using ReaderWriterLock
314(1)
Some Other Concurrency Primitives
314(1)
Summary
315(2)
Chapter 12 Symbolic Programming with Structured Data
317(28)
Verifying Circuits with Propositional Logic
317(1)
Representing Propositional Logic
318(2)
Evaluating Propositional Logic Naively
320(2)
From Circuits to Propositional Logic
322(4)
Checking Simple Properties of Circuits
326(1)
Representing Propositional Formulae Efficiently Using BDDs
326(4)
Circuit Verification with BDDs
330(2)
Expression Simplification and Differentiation
332(2)
Implementing Local Simplifications
334(1)
A Richer Language of Algebraic Expressions
335(1)
Parsing Algebraic Expressions
336(3)
Simplifying Algebraic Expressions
339(2)
Symbolic Differentiation of Algebraic Expressions
341(1)
The Driver
342(1)
The Web API
343(1)
Summary
344(1)
Chapter 13 Integrating External Data and Services
345(18)
Some Basic REST Requests
346(1)
Getting Data in JSON Format
347(1)
Parsing and Handling Multiple Pages
348(1)
Getting Started with Queries
349(1)
Example: Language-Integrated SQL
350(2)
Sorting
352(1)
Aggregation
352(1)
Nullables
353(1)
Inner Queries
353(1)
Grouping
354(1)
Joins
354(1)
More Choices for SQL
355(2)
Directly Embedding T-SQL Using SqICommandProvider
357(1)
Raw Access to Databases Using ADO.NET
357(1)
Establishing Connections Using ADO.NET
358(1)
Creating a Database Using ADO.NET
359(1)
Creating Tables Using ADO.NET
359(2)
Using Stored Procedures via ADO.NET
361(1)
Summary
362(1)
Chapter 14 Building Smart Web Applications
363(54)
Serving Web Content Directly
363(6)
Rich Client Web Applications with WebSharper
369(1)
Getting Started with WebSharper
370(3)
Pagelets - Working with Reactive HTML and Client-Side Code
373(6)
HTML Templates
379(4)
Sitelets
383(12)
Developing REST Applications
395(6)
Formlets and Piglets: Building Functional Web Forms
401(11)
Automated Resource Tracking and Handling
412(1)
Using Third-Party JavaScript Libraries
413(1)
Working with .NET Proxies
414(1)
Summary
415(2)
Chapter 15 Visualization and Graphical User Interfaces
417(48)
Getting Started with Eto
417(1)
Writing "Hello, World!" in a Click
418(1)
Understanding the Anatomy of a Graphical Application
419(1)
Composing Controls and Menus
420(3)
Composing User Interfaces
423(3)
Drawing Applications
426(5)
Creating a Mandelbrot Viewer
431(1)
Computing Mandelbrot
432(1)
Setting Colors
433(3)
Creating the Visualization Application
436(2)
Creating the Application Plumbing
438(6)
Writing Your Own Controls
444(1)
Developing a Custom Control
444(2)
Anatomy of a Control
446(2)
The World, the View, and Coordinate Systems
448(1)
Drawing an Analog Clock
448(5)
World and View Coordinates
453(4)
Lightweight Controls
457(7)
Summary
464(1)
Chapter 16 Language-Oriented Programming
465(30)
Computation Expressions
466(2)
An Example: Success/Failure Computation Expressions
468(3)
Defining a Computation-Expression Builder
471(3)
Computation Expressions and Untamed Side Effects
474(1)
Computation Expressions with Custom Query Operators
475(1)
Example: Probabilistic Computations
476(4)
Combining Computation Expressions and Resources
480(1)
Recursive Workflow Expressions
481(1)
Using F# Reflection
481(1)
Reflecting on Types
481(1)
Schema Compilation by Reflecting on Types
482(3)
Using the F# Dynamic Reflection Operators
485(1)
Using F# Quotations
486(1)
Example: Using F# Quotations for Error Estimation
487(2)
Resolving Reflected Definitions
489(1)
Writing an F# Type Provider
490(3)
Summary
493(2)
Chapter 17 Libraries and Interoperability
495(24)
Types, Memory, and Interoperability
495(1)
Libraries: A High-Level Overview
496(1)
Namespaces from the .NET Framework
497(1)
Namespaces from FSharp.Core and FSharp.Data Libraries
498(1)
Some F# Community Libraries
499(1)
Using the System Types
499(1)
Using Further F# and .NET Data Structures
500(1)
System.Collections.Generic and Other .NET Collections
501(1)
Supervising and Isolating Execution
502(1)
Further Libraries for Reflective Techniques
502(1)
Using General Types
502(1)
Using FSharp.Reflection
503(1)
Some Other .NET Types You May Encounter
503(1)
Some F# Community Type Providers
504(1)
Under the Hood: Interoperating with C# and Other .NET Languages
505(2)
Memory Management at Runtime
507(1)
Interoperating with C and C++ with Plnvoke
508(1)
Getting Started with Plnvoke
509(2)
Mapping C Data Structures to F# Code
511(1)
Marshalling Parameters to and from C
512(2)
Marshalling Strings to and from C
514(2)
Passing Function Pointers to C
516(1)
Wrapper Generation and the Limits of Plnvoke
517(1)
Summary
518(1)
Chapter 18 Developing and Testing F# Code
519(22)
Developing Your Code
519(1)
Editing Your Code
520(1)
Mixing Scripting and Compiled Code
520(1)
Choosing Optimization Settings
521(1)
Generating Documentation
521(1)
Building Libraries
522(1)
Using Static Linking
523(1)
Packaging Different Kinds of Code
523(1)
Managing Dependencies
524(1)
Using Data and Configuration Settings
524(1)
Using F# Interactive Effectively
525(1)
Controlling F# Interactive
526(1)
Some Common F# Interactive Directives
527(1)
Understanding How F# Interactive Compiles Code
527(1)
Using Tracing Diagnostics
528(3)
Debugging Your Code with an IDE
531(2)
Debugging Across Multiple Languages
533(1)
Debugging Concurrent Applications
534(1)
Testing Your Code
535(2)
Using Test Fixtures in NUnit/XUnit
537(2)
Combining NUnit/XUnit and F# Interactive Debugging
539(1)
Property-based Testing Using FsCheck
539(1)
Summary
540(1)
Chapter 19 Designing F# Libraries
541(18)
Designing Vanilla .NET Libraries
542(4)
Understanding Functional-Design Methodology
546(1)
Understanding Where Functional Programming Comes From
546(2)
Understanding Functional-Design Methodology
548(1)
Applying the Good Library Design to F#
549(1)
Recommendation: Use Correct Naming and Capitalization Conventions Where Possible
549(3)
Recommendation: Avoid Using Underscores in Names
552(1)
Recommendation: Follow the Recommended Guidelines for Exceptions
552(1)
Recommendation: Consider Using Option Values for Return Types Instead of Raising Exceptions
553(1)
Recommendation: Follow the Recommended Guidelines for Value Types
553(1)
Recommendation: Consider Using Explicit Signature Files for Your Framework
553(1)
Recommendation: Consider Avoiding the Use of Implementation Inheritance for Extensibility
553(1)
Recommendation: Use Properties and Methods for Attributes and Operations Essential to a Type
554(1)
Recommendation: Avoid Revealing Concrete Data Representations Such as Records
554(1)
Recommendation: Use Active Patterns to Hide the Implementations of Discriminated Unions
554(1)
Recommendation: Use Object-Interface Types Instead of Tuples or Records of Functions
555(1)
Recommendation: Understand When Currying Is Useful in Functional Programming APIs
555(1)
Recommendation: Use Tuples for Return Values, Arguments, and Intermediate Values
556(1)
Recommendation: Use Async for Asynchronous Computations
556(1)
Recommendation: Use Choice or a Named Type for Alternative Results
556(1)
Some Recommended Coding Idioms
556(1)
Recommendation: Use the Standard Operators
557(1)
Recommendation: Place the Pipeline Operator | > at the Start of a Line
557(1)
Recommendation: Format Object Expressions Using the member Syntax
557(1)
Summary
558(1)
Appendix F# Brief Language Guide
559(8)
Comments and Attributes
559(1)
Basic Types and Literals
559(1)
Types
560(1)
Patterns and Matching
560(1)
Functions, Composition, and Pipelining
560(1)
Binding and Control Flow
561(1)
Exceptions
561(1)
Tuples, Arrays, Lists, and Collections
562(1)
Operators
563(1)
Type Definitions and Objects
564(1)
Namespaces and Modules
565(1)
Sequence Expressions and Workflows
565(1)
Queries and Quotations
566(1)
Index 567
Don Syme is a principal researcher at Microsoft Research, and the main designer of F#. Since joining Microsoft Research in 1998, he has been a seminal contributor to a wide variety of leading-edge projects, including generics in C# and the .NET Common Language Runtime, F# itself, F# asynchronous programming, and units of measure in F#. He received a Ph.D. from the University of Cambridge Computer Laboratory in 1999.

Adam Granicz is the chief executive officer of IntelliFactory, the leading provider of F# training, development and consulting services, and technologies that enable rapid functional, reactive web development. He has over eight years of experience applying F# in commercial projects, and works on WebSharper, IntelliFactorys web development platform that offers unrivaled productivity, a uniform programming model based on F#, and the fastest way to develop robust, client-based rich Internet and mobile applications. Adam is an active F# evangelist, a regular F# author and speaker at development conferences and workshops, and serves on the steering committee of the Commercial Users of Functional Programming (CUFP) Workshop, representing the F# segment.

Antonio Cisternino is an assistant professor in the Computer Science Department of the University of Pisa. His primary research is on scientific computing, meta-programming and domain-specific languages on virtual-machine-based execution environments. He has been active in the .NET community since 2001 and developed VSLab, a Microsoft Visual Studio add-in to support MATLAB-like programming in F# and Visual Studio. He is also author of annotated C#, an extension of C#, and Robotics4.NET, a framework for programming robots with Microsoft .NET. Cisternino holds a Ph.D. in Computer Science from the University of Pisa.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97814842074062e.html
Märksõnad: