skip to content
Expert F♯ 4.0 Preview this item
ClosePreview this item
Checking...

Expert F♯ 4.0

Author: Don Syme; Adam Granicz; Antonio Cisternino
Publisher: [Berkeley, California] : Apress, New York, NY : Distributed to the Book trade worldwide by Springer 2015. ©2015
Edition/Format:   eBook : Document : English : Fourth editionView all editions and formats
Summary:
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,  Read more...
Rating:

(not yet rated) 0 with reviews - Be the first.

Subjects
More like this

Find a copy online

Links to this item

Find a copy in the library

&AllPage.SpinnerRetrieving; Finding libraries that hold this item...

Details

Genre/Form: Electronic books
Additional Physical Format: Printed edition:
Material Type: Document, Internet resource
Document Type: Internet Resource, Computer File
All Authors / Contributors: Don Syme; Adam Granicz; Antonio Cisternino
ISBN: 9781484207406 1484207408
OCLC Number: 934083911
Notes: Includes index.
Description: 1 online resource (xxvii, 582 pages) : illustrations
Contents: Machine generated contents note: ch. 1 Introduction --
Genesis of F# --
About This Book --
Who This Book Is For --
ch. 2 Your First F# Program: Getting Started with F# --
Creating Your First F# Program --
Documenting Code --
Using let --
Understanding Types --
Calling Functions --
Lightweight Syntax --
Understanding Scope --
Using Data Structures --
Using Properties and the Dot-Notation --
Using Tuples --
Using Imperative Code --
Using Object-Oriented Libraries from F# --
Using open to Access Namespaces and Modules --
Fetching a Web Page --
Getting and Using Packages --
Accessing External Data Using F# Packages --
Starting a Web Server and Serving Data using F# Packages --
Summary --
ch. 3 Introducing Functional Programming --
Starting with Numbers and Strings --
Some Simple Types and Literals --
Arithmetic Conversions --
Arithmetic Comparisons --
Simple Strings --
Working with Conditionals: && and II --
Defining Recursive Functions --
Lists --
Options --
Getting Started with Pattern Matching --
Matching on Structured Values --
Guarding Rules and Combining Patterns --
Further Ways of Forming Patterns --
Introducing Function Values --
Using Function Values --
Computing with Collection Functions --
Using Fluent Notation on Collections --
Composing Functions with >> --
Building Functions with Partial Application --
Using Local Functions --
Iterating with Functions --
Abstracting Control with Functions --
Using Object Methods as First-Class Functions --
Some Common Uses of Function Values --
Summary --
ch. 4 Introducing Imperative Programming --
About Functional and Imperative Programming --
Imperative Looping and Iterating --
Simple for Loops --
Simple While Loops --
More Iteration Loops over Sequences --
Using Mutable Records --
Avoiding Aliasing --
Using Mutable let Bindings --
Hiding Mutable Data --
Working with Arrays --
Generating and Slicing Arrays --
Two-Dimensional Arrays --
Introducing the Imperative .NET Collections --
Using Resizable Arrays --
Using Dictionaries --
Using Dictionary's TryGetValue --
Using Dictionaries with Compound Keys --
Some Other Mutable Data Structures --
Exceptions and Controlling Them --
Catching Exceptions --
Using try . . . finally --
Defining New Exception Types --
Having an Effect: Basic I/O --
.NET I/O via Streams --
Some Other I/O-Related Types --
Using System.Console --
Combining Functional and Imperative Efficient Precomputation and Caching --
Precomputation and Partial Application --
Precomputation and Objects --
Memoizing Computations --
Lazy Values --
Other Variations on Caching and Memoization --
Mutable Reference Cells --
Combining Functional and Imperative: Functional Programming with Side Effects --
Consider Replacing Mutable Locals and Loops with Recursion --
Separating Pure Computation from Side-Effecting Computations --
Separating Mutable Data Structures --
Not All Side Effects Are Equal --
Avoid Combining Imperative Programming and Laziness --
Summary --
ch. 5 Understanding Types in Functional Programming --
Exploring Some Simple Type Definitions --
Defining Type Abbreviations --
Defining Record Types --
Handling Non-Unique Record Field Names --
Cloning Records --
Defining Discriminated Unions --
Using Discriminated Unions as Records --
Defining Multiple Types Simultaneously --
Understanding Generics --
Writing Generic Functions --
Some Important Generic Functions --
Making Things Generic --
Generic Algorithms through Explicit Arguments --
Generic Algorithms through Function Parameters --
Generic Algorithms through Inlining --
More on Different Kinds of Types --
Reference Types and Value Types --
Other Flavors of .NET Types --
Understanding Subtyping --
Casting Up Statically --
Casting Down Dynamically --
Performing Type Tests via Pattern Matching --
Knowing When Upcasts Are Applied Automatically --
Flexible Types --
Troubleshooting Type-Inference Problems --
Using a Visual Editing Environment --
Using Type Annotations --
Understanding the Value Restriction --
Working Around the Value Restriction --
Understanding Generic Overloaded Operators --
Summary --
ch. 6 Programming with Objects --
Getting Started with Objects and Members --
Using Classes --
Adding Further Object Notation to Your Types --
Working with Indexer Properties --
Adding Overloaded Operators --
Using Named and Optional Arguments --
Adding Method Overloading --
Defining Object Types with Mutable State --
Using Optional Property Settings --
Declaring Auto-Properties --
Getting Started with Object Interface Types --
Defining New Object Interface Types --
Implementing Object Interface Types Using Object Expressions --
Implementing Object Interface Types Using Concrete Types --
Using Common Object Interface Types from the .NET Libraries --
Understanding Hierarchies of Object Interface Types --
More Techniques for Implementing Objects --
Combining Object Expressions and Function Parameters --
Defining Partially Implemented Class Types --
Using Partially Implemented Types via Delegation --
Using Partially Implemented Types via Implementation Inheritance --
Combining Functional and Objects: Cleaning Up Resources --
Resources and IDisposable --
Managing Resources with More-Complex Lifetimes --
Cleaning Up Internal Objects --
Cleaning Up Unmanaged Objects --
Extending Existing Types and Modules --
Working with F# Objects and .NET Types --
Structs --
Delegates --
Enums --
Working with null Values --
Summary --
ch. 7 Encapsulating and Organizing Your Code --
Hiding Things --
Hiding Things with Local Definitions --
Hiding Things with Accessibility Annotations --
Organizing Code with Namespaces and Modules --
Putting Your Code in a Module --
Putting Your Modules and Types in Namespaces --
Defining a Module with the Same Name as a Type --
Preventing Client Code from Opening a Module --
Using Files as Modules --
Automatically Opening Modules --
Projects, Assemblies, and Compilation Order --
Creating Assemblies, DLLs, and EXEs --
Project Files and Compilation Order --
Using Signature Files --
Designing with Signatures --
When Are Signature Types Checked? --
Reusing Your Code --
Using Files as Small Reusable Components --
Creating and Sharing Packages --
Summary --
ch. 8 Working with Textual Data --
Building Strings and Formatting Data --
Building Strings --
More about String Literals --
Using printf and Friends --
Generic Structural Formatting --
Formatting Strings Using .NET Formatting --
Parsing Strings and Textual Data --
Parsing Basic Values --
Processing Line-Based Input --
Using Regular Expressions --
More on Matching with System.Text.RegularExpressions --
More Robust Code with the Regular Expression Type Provider --
Using XML as a Concrete Language Format --
Using the System.Xml Namespace --
From Concrete XML to Abstract Syntax --
Using the FSharp.Data XmlTypeProvider --
Using JSON as a Concrete Language Format --
Parsing JSON Data --
Using the FSharp.Data JsonProvider --
Some Recursive Descent Parsing --
Simple Tokenizer --
Recursive-Descent Parsing --
Binary Parsing and Formatting --
Encoding and Decoding Unicode Strings --
Encoding and Decoding Binary Data --
Summary --
ch. 9 Working with Sequences and Tree-Structured Data --
Getting Started with Sequences --
Using Range Expressions --
Iterating a Sequence --
Transforming Sequences with Functions --
Which Types Can Be Used as Sequences? --
Using Lazy Sequences from External Sources --
Using Sequence Expressions --
Enriching Sequence Expressions with Additional Logic --
Generating Lists and Arrays Using Sequence Expressions --
More on Working with Sequences --
Using Other Sequence Operators: Truncate and Sort --
Selecting Multiple Elements from Sequences --
Finding Elements and Indexes in Sequences --
Grouping and Indexing Sequences --
Folding Sequences --
Cleaning Up in Sequence Expressions --
Expressing Operations Using Sequence Expressions --
Structure beyond Sequences: Domain Modeling --
Transforming Domain Models --
Using On-Demand Computation with Domain Models --
Caching Properties in Domain Models --
Memoizing Construction of Domain Model Nodes --
Active Patterns: Views for Structured Data --
Converting the Same Data to Many Views --
Matching on .NET Object Types --
Defining Partial and Parameterized Active Patterns --
Hiding Representations with Active Patterns --
Equality, Hashing, and Comparison --
Asserting Equality, Hashing, and Comparison Using Attributes --
Fully Customizing Equality, Hashing, and Comparison on a Type --
Suppressing Equality, Hashing, and Comparison on a Type --
Customizing Generic Collection Types --
Tail Calls and Recursive Programming --
Tail Recursion and List Processing --
Tail Recursion and Object-Oriented Programming --
Tail Recursion and Processing Unbalanced Trees --
Using Continuations to Avoid Stack Overflows --
Another Example: Processing Syntax Trees --
Summary --
ch. 10 Numeric Programming and Charting --
Getting Started with FsLab --
Basic Charting with FSharp.Charting --
Basic Numeric Types and Literals --
Arithmetic Operators --
Checked Arithmetic --
Arithmetic Conversions --
Arithmetic Comparisons --
Overloaded Math Functions --
Bitwise Operations --
Sequences, Statistics, and Numeric Code --
Summing, Averaging, Maximizing, and Minimizing Sequences --
Counting and Categorizing --
Writing Fresh Numeric Code --
Making Numeric Code Generic --
Example: KMeans --
Statistics, Linear Algebra, and Distributions with Math.NET Note continued: Basic Statistical Functions in Math.NET Numerics --
Using Histograms and Distributions from Math.NET Numerics --
Using Matrices and Vectors from Math.NET --
Matrix Inverses, Decomposition, and Eigenvalues --
Time Series and Data Frames with Deedle --
Units of Measure --
Adding Units to a Numeric Algorithms --
Adding Units to a Type Definition --
Applying and Removing Units --
Some Limitations of Units of Measure --
Summary --
ch. 11 Reactive, Asynchronous, and Parallel Programming --
Introducing Terminology --
Events --
Creating and Publishing Events --
Events as First-Class Values --
From Events to Observables --
Asynchronous Computations --
Fetching Multiple Web Pages in Parallel, Asynchronously --
Understanding Asynchronous Computations --
Example: Parallel File Processing Using Async Computations --
Running Async Computations --
Common I/O Operations in Asynchronous Computations --
Understanding Exceptions and Cancellations --
Interoperating with .NET Tasks --
Agents --
Introducing Agents --
Creating Objects That React to Messages --
Scanning Mailboxes for Relevant Messages --
Example: An Asynchronous Agent for Web Crawling --
Example: Using async for CPU Parallelism --
Under the Hood: Implementing Async.Parallel --
Using Shared-Memory Concurrency --
Creating Threads Explicitly --
Creating Tasks Explicitly --
Shared Memory, Race Conditions, and the .NET Memory Model --
Using Locks to Avoid Race Conditions --
Using ReaderWriterLock --
Some Other Concurrency Primitives --
Summary --
ch. 12 Symbolic Programming with Structured Data --
Verifying Circuits with Propositional Logic --
Representing Propositional Logic --
Evaluating Propositional Logic Naively --
From Circuits to Propositional Logic --
Checking Simple Properties of Circuits --
Representing Propositional Formulae Efficiently Using BDDs --
Circuit Verification with BDDs --
Expression Simplification and Differentiation --
Implementing Local Simplifications --
Richer Language of Algebraic Expressions --
Parsing Algebraic Expressions --
Simplifying Algebraic Expressions --
Symbolic Differentiation of Algebraic Expressions --
Driver --
Web API --
Summary --
ch. 13 Integrating External Data and Services --
Some Basic REST Requests --
Getting Data in JSON Format --
Parsing and Handling Multiple Pages --
Getting Started with Queries --
Example: Language-Integrated SQL --
Sorting --
Aggregation --
Nullables --
Inner Queries --
Grouping --
Joins --
More Choices for SQL --
Directly Embedding T-SQL Using SqICommandProvider --
Raw Access to Databases Using ADO.NET --
Establishing Connections Using ADO.NET --
Creating a Database Using ADO.NET --
Creating Tables Using ADO.NET --
Using Stored Procedures via ADO.NET --
Summary --
ch. 14 Building Smart Web Applications --
Serving Web Content Directly --
Rich Client Web Applications with WebSharper --
Getting Started with WebSharper --
Pagelets --
Working with Reactive HTML and Client-Side Code --
HTML Templates --
Sitelets --
Developing REST Applications --
Formlets and Piglets: Building Functional Web Forms --
Automated Resource Tracking and Handling --
Using Third-Party JavaScript Libraries --
Working with .NET Proxies --
Summary --
ch. 15 Visualization and Graphical User Interfaces --
Getting Started with Eto --
Writing "Hello, World!" in a Click --
Understanding the Anatomy of a Graphical Application --
Composing Controls and Menus --
Composing User Interfaces --
Drawing Applications --
Creating a Mandelbrot Viewer --
Computing Mandelbrot --
Setting Colors --
Creating the Visualization Application --
Creating the Application Plumbing --
Writing Your Own Controls --
Developing a Custom Control --
Anatomy of a Control --
World, the View, and Coordinate Systems --
Drawing an Analog Clock --
World and View Coordinates --
Lightweight Controls --
Summary --
ch. 16 Language-Oriented Programming --
Computation Expressions --
Example: Success/Failure Computation Expressions --
Defining a Computation-Expression Builder --
Computation Expressions and Untamed Side Effects --
Computation Expressions with Custom Query Operators --
Example: Probabilistic Computations --
Combining Computation Expressions and Resources --
Recursive Workflow Expressions --
Using F# Reflection --
Reflecting on Types --
Schema Compilation by Reflecting on Types --
Using the F# Dynamic Reflection Operators --
Using F# Quotations --
Example: Using F# Quotations for Error Estimation --
Resolving Reflected Definitions --
Writing an F# Type Provider --
Summary --
ch. 17 Libraries and Interoperability --
Types, Memory, and Interoperability --
Libraries: A High-Level Overview --
Namespaces from the .NET Framework --
Namespaces from FSharp.Core and FSharp.Data Libraries --
Some F# Community Libraries --
Using the System Types --
Using Further F# and .NET Data Structures --
System.Collections.Generic and Other .NET Collections --
Supervising and Isolating Execution --
Further Libraries for Reflective Techniques --
Using General Types --
Using FSharp.Reflection --
Some Other .NET Types You May Encounter --
Some F# Community Type Providers --
Under the Hood: Interoperating with C# and Other .NET Languages --
Memory Management at Runtime --
Interoperating with C and C++ with Plnvoke --
Getting Started with Plnvoke --
Mapping C Data Structures to F# Code --
Marshalling Parameters to and from C --
Marshalling Strings to and from C --
Passing Function Pointers to C --
Wrapper Generation and the Limits of Plnvoke --
Summary --
ch. 18 Developing and Testing F# Code --
Developing Your Code --
Editing Your Code --
Mixing Scripting and Compiled Code --
Choosing Optimization Settings --
Generating Documentation --
Building Libraries --
Using Static Linking --
Packaging Different Kinds of Code --
Managing Dependencies --
Using Data and Configuration Settings --
Using F# Interactive Effectively --
Controlling F# Interactive --
Some Common F# Interactive Directives --
Understanding How F# Interactive Compiles Code --
Using Tracing Diagnostics --
Debugging Your Code with an IDE --
Debugging Across Multiple Languages --
Debugging Concurrent Applications --
Testing Your Code --
Using Test Fixtures in NUnit/XUnit --
Combining NUnit/XUnit and F# Interactive Debugging --
Property-based Testing Using FsCheck --
Summary --
ch. 19 Designing F# Libraries --
Designing Vanilla .NET Libraries --
Understanding Functional-Design Methodology --
Understanding Where Functional Programming Comes From --
Understanding Functional-Design Methodology --
Applying the Good Library Design to F# --
Recommendation: Use Correct Naming and Capitalization Conventions Where Possible --
Recommendation: Avoid Using Underscores in Names --
Recommendation: Follow the Recommended Guidelines for Exceptions --
Recommendation: Consider Using Option Values for Return Types Instead of Raising Exceptions --
Recommendation: Follow the Recommended Guidelines for Value Types --
Recommendation: Consider Using Explicit Signature Files for Your Framework --
Recommendation: Consider Avoiding the Use of Implementation Inheritance for Extensibility --
Recommendation: Use Properties and Methods for Attributes and Operations Essential to a Type --
Recommendation: Avoid Revealing Concrete Data Representations Such as Records --
Recommendation: Use Active Patterns to Hide the Implementations of Discriminated Unions --
Recommendation: Use Object-Interface Types Instead of Tuples or Records of Functions --
Recommendation: Understand When Currying Is Useful in Functional Programming APIs --
Recommendation: Use Tuples for Return Values, Arguments, and Intermediate Values --
Recommendation: Use Async for Asynchronous Computations --
Recommendation: Use Choice or a Named Type for Alternative Results --
Some Recommended Coding Idioms --
Recommendation: Use the Standard Operators --
Recommendation: Place the Pipeline Operator Recommendation: Format Object Expressions Using the member Syntax --
Summary --
Appendix F# Brief Language Guide --
Comments and Attributes --
Basic Types and Literals --
Types --
Patterns and Matching --
Functions, Composition, and Pipelining --
Binding and Control Flow --
Exceptions --
Tuples, Arrays, Lists, and Collections --
Operators --
Type Definitions and Objects --
Namespaces and Modules --
Sequence Expressions and Workflows --
Queries and Quotations.
Responsibility: Don Syme, Adam Granicz, Antonio Cisternino.

Abstract:

"User level: intermediate-advanced"--Back cover.  Read more...

Reviews

User-contributed reviews
Retrieving GoodReads reviews...
Retrieving DOGObooks reviews...

Tags

Be the first.
Confirm this request

You may have already requested this item. Please select Ok if you would like to proceed with this request anyway.

Linked Data


Primary Entity

<http://www.worldcat.org/oclc/934083911> # Expert F♯ 4.0
    a schema:MediaObject, schema:Book, schema:CreativeWork ;
    library:oclcnum "934083911" ;
    library:placeOfPublication <http://id.loc.gov/vocabulary/countries/cau> ;
    rdfs:comment "Warning: This malformed URI has been treated as a string - 'https://ebookcentral.proquest.com/lib/unt/detail.action?docID=4307138";'" ;
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#Topic/computers_software_development_&_engineering_general> ; # COMPUTERS--Software Development & Engineering--General
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#Topic/programming_languages_compilers_interpreters> ; # Programming Languages, Compilers, Interpreters
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#Topic/engineering_&_applied_sciences> ; # Engineering & Applied Sciences
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#Topic/f♯_computer_program_language> ; # F♯ (Computer program language)
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#Topic/functional_programming_languages> ; # Functional programming languages
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#Topic/computer_science> ; # Computer Science
    schema:about <http://dewey.info/class/005.133/e23/> ;
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#CreativeWork/microsoft_net_framework> ; # Microsoft .NET Framework.
    schema:about <http://experiment.worldcat.org/entity/work/data/2971410111#Topic/programming_&_scripting_languages_general> ; # Programming & scripting languages: general
    schema:author <http://experiment.worldcat.org/entity/work/data/2971410111#Person/granicz_adam> ; # Adam Granicz
    schema:author <http://experiment.worldcat.org/entity/work/data/2971410111#Person/cisternino_antonio> ; # Antonio Cisternino
    schema:author <http://experiment.worldcat.org/entity/work/data/2971410111#Person/syme_don> ; # Don Syme
    schema:bookEdition "Fourth edition." ;
    schema:bookFormat schema:EBook ;
    schema:copyrightYear "2015" ;
    schema:datePublished "2015" ;
    schema:description "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!"@en ;
    schema:exampleOfWork <http://worldcat.org/entity/work/id/2971410111> ;
    schema:genre "Electronic books"@en ;
    schema:inLanguage "en" ;
    schema:isSimilarTo <http://worldcat.org/entity/work/data/2971410111#CreativeWork/> ;
    schema:name "Expert F♯ 4.0"@en ;
    schema:productID "934083911" ;
    schema:url <http://public.eblib.com/choice/publicfullrecord.aspx?p=4307138> ;
    schema:url <http://proquest.safaribooksonline.com/9781484207406> ;
    schema:url <http://link.springer.com/10.1007/978-1-4842-0740-6> ;
    schema:url <http://libproxy.uwyo.edu/login/?url=http://dx.doi.org/10.1007/978-1-4842-0740-6> ;
    schema:url <https://0-link-springer-com.pugwash.lib.warwick.ac.uk/book/10.1007/978-1-4842-0740-6> ;
    schema:url <https://login.libproxy.uregina.ca:8443/login?url=http://proquest.safaribooksonline.com/9781484207406> ;
    schema:url <https://proquest.safaribooksonline.com/9781484207406> ;
    schema:url <http://search.ebscohost.com/login.aspx?direct=true&scope=site&db=nlebk&db=nlabk&AN=1170308> ;
    schema:url <http://rave.ohiolink.edu/ebooks/ebc/9781484207406> ;
    schema:url <http://proxy.library.carleton.ca/login?url=http://books.scholarsportal.info/viewdoc.html?id=/ebooks/ebooks3/springer/2017-08-17/1/9781484207406> ;
    schema:url <https://link.springer.com/10.1007/978-1-4842-0740-6> ;
    schema:url <https://www.safaribooksonline.com/library/view/-/9781484207406/?ar> ;
    schema:url <http://link.springer.com/openurl?genre=book&isbn=978-1-4842-0741-3> ;
    schema:url <https://safarijv.auth0.com/authorize?client_id=UtNi1m1IRXgzYFIwZrhSxell9EDRaL2v&response_type=code&connection=glasgow-caledonian-university&redirect_uri=https://www.safaribooksonline.com/complete/auth0-oauth2/&state=/library/view/-/9781484207406/?ar> ;
    schema:url <https://login.libproxy.uregina.ca:8443/login?url=https://link.springer.com/openurl?genre=book&isbn=978-1-4842-0741-3> ;
    schema:url "https://ebookcentral.proquest.com/lib/unt/detail.action?docID=4307138";" ;
    schema:url <https://cornell-library.skillport.com/skillportfe/main.action?assetid=112025> ;
    schema:url <https://safarijv.auth0.com/authorize?client_id=UtNi1m1IRXgzYFIwZrhSxell9EDRaL2v&response_type=code&connection=centennial-college&redirect_uri=https://www.safaribooksonline.com/complete/auth0-oauth2/&state=/library/view/-/9781484207406/?ar> ;
    schema:url <http://www.books24x7.com/marc.asp?bookid=112025> ;
    schema:url <http://proxy.library.carleton.ca/login?url=http://link.springer.com/10.1007/978-1-4842-0740-6> ;
    schema:url <https://link.springer.com/openurl?genre=book&isbn=978-1-4842-0741-3> ;
    schema:url <http://dx.doi.org/10.1007/978-1-4842-0740-6> ;
    schema:url <https://doi.org/10.1007/978-1-4842-0740-6> ;
    schema:url <http://public.ebookcentral.proquest.com/choice/publicfullrecord.aspx?p=4307138> ;
    schema:url <http://www.myilibrary.com?id=884366> ;
    schema:url <http://remote.baruch.cuny.edu/login?url=http://library.books24x7.com/library.asp?> ;
    schema:url <https://grinnell.idm.oclc.org/login?url=http://link.springer.com/10.1007/978-1-4842-0740-6> ;
    schema:workExample <http://worldcat.org/isbn/9781484207406> ;
    schema:workExample <http://dx.doi.org/10.1007/978-1-4842-0740-6> ;
    umbel:isLike <http://bnb.data.bl.uk/id/resource/GBB8O2025> ;
    wdrs:describedby <http://www.worldcat.org/title/-/oclc/934083911> ;
    .


Related Entities

<http://experiment.worldcat.org/entity/work/data/2971410111#CreativeWork/microsoft_net_framework> # Microsoft .NET Framework.
    a schema:CreativeWork ;
    schema:name "Microsoft .NET Framework." ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Person/cisternino_antonio> # Antonio Cisternino
    a schema:Person ;
    schema:familyName "Cisternino" ;
    schema:givenName "Antonio" ;
    schema:name "Antonio Cisternino" ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Person/granicz_adam> # Adam Granicz
    a schema:Person ;
    schema:familyName "Granicz" ;
    schema:givenName "Adam" ;
    schema:name "Adam Granicz" ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Topic/computers_software_development_&_engineering_general> # COMPUTERS--Software Development & Engineering--General
    a schema:Intangible ;
    schema:name "COMPUTERS--Software Development & Engineering--General"@en ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Topic/engineering_&_applied_sciences> # Engineering & Applied Sciences
    a schema:Intangible ;
    schema:name "Engineering & Applied Sciences"@en ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Topic/functional_programming_languages> # Functional programming languages
    a schema:Intangible ;
    schema:name "Functional programming languages"@en ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Topic/f♯_computer_program_language> # F♯ (Computer program language)
    a schema:Intangible ;
    schema:name "F♯ (Computer program language)"@en ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Topic/programming_&_scripting_languages_general> # Programming & scripting languages: general
    a schema:Intangible ;
    schema:name "Programming & scripting languages: general"@en ;
    .

<http://experiment.worldcat.org/entity/work/data/2971410111#Topic/programming_languages_compilers_interpreters> # Programming Languages, Compilers, Interpreters
    a schema:Intangible ;
    schema:name "Programming Languages, Compilers, Interpreters"@en ;
    .

<http://worldcat.org/isbn/9781484207406>
    a schema:ProductModel ;
    schema:isbn "1484207408" ;
    schema:isbn "9781484207406" ;
    .

<https://login.libproxy.uregina.ca:8443/login?url=https://link.springer.com/openurl?genre=book&isbn=978-1-4842-0741-3>
    rdfs:comment "Full text available from SpringerLINK ebooks - English/International Collection (2015)" ;
    .

<https://www.safaribooksonline.com/library/view/-/9781484207406/?ar>
    rdfs:comment "Connect to this resource online" ;
    .


Content-negotiable representations

Close Window

Please sign in to WorldCat 

Don't have an account? You can easily create a free account.