Skip to main content

Home/ Coders/ Group items matching "map" in title, tags, annotations or url

Group items matching
in title, tags, annotations or url

Sort By: Relevance | Date Filter: All | Bookmarks | Topics Simple Middle
1More

Exhibition Stall Layout And Booking-International Spice Conference 2016 - 0 views

www.internationalspiceconference.com/exhibition-stall-booking.html exhibition layout spice conference
shared by spicesboard on 17 Sep 15 - No Cached
  • spicesboard on 17 Sep 15
     
    Witness the world of spices converges to one global platform, at the International Spice Conference 2016. Interaction between producers, manufactures, exporters etc-Spices. World spice routes, World spice map.
1More

Microsoft Win32 to Microsoft .NET Framework API Map - 0 views

msdn2.microsoft.com/...aa302340.aspx .net @public api development win32
shared by Joel Bennett on 26 May 07 - Cached
  • Joel Bennett on 26 May 07
     
    Microsoft's map from Win32 to .Net Framework APIs.  It's a bit outdated (from .Net 1.1), but I can't find an updated version.
1More

Sync Framework Samples - 0 views

blogs.msdn.com/...nc-framework-code-gallery.aspx development livemesh sync syncframework
shared by Joel Bennett on 06 May 08 - Cached
  • Joel Bennett on 06 May 08
     
    There's a contact synchronization sample highlighted here which includes synchronizing contacts between Outlook, Vista Contacts and VCard files. Not only do I need this app ... it really shows off the concept of data mapping between disparate data sources.
1More

dbscript php framework - 0 views

dbscript.net php rest framework programming
shared by anonymous on 18 Dec 08 - Cached
  • anonymous on 18 Dec 08
     
    dbscript is a web development framework, it helps php programmers take advantage of efficient design patterns and idioms from other dynamic languages and frameworks. for example, the Mapper and Route classes work together to Map actions and records to distinct urls. among the many advantages of routes are the automatic named routes: url_for( resource ). restful urls, http-style controllers, atompub/html introspection documents and content-negotiation are among the sophisticated features of this programmer-centric development tool. the framework is a database abstraction layer, with built-in adapters for PostgreSQL and MySQL.
1More

Functional Javascript - 0 views

osteele.com/...functional javascript functional programming library
shared by anonymous on 10 Feb 09 - Cached
Emma Deloney liked it
  • anonymous on 10 Feb 09
     
    Functional is a library for functional programming in JavaScript. It defines the standard higher-order functions such as map, reduce (aka foldl), and select (aka filter). It also defines functions such as curry, rcurry, and partial for partial function application; and compose, guard, and until for function-level programming. And all these functions accept strings, such as 'x -> x+1', 'x+1', or '+1' as synonyms for the more verbose function(x) {return x+1}.
1More

XML Data Binding Resources - 0 views

www.rpbourret.com/...XMLDataBinding.htm development reference resources tools xml
shared by Joel Bennett on 26 Jun 08 - Cached
  • Joel Bennett on 26 Jun 08
     
    Mapping XML to UML, Objects, Source Code, etc. Handling SOAP, and more. A great collections of links.
1More

CLI - Command Line Interface Definition Language for C++ - Project Page - 0 views

www.codesynthesis.com/...cli programming cpp c++ cli Development command line interface
shared by Andreas Wagner on 25 Dec 09 - No Cached
  • Andreas Wagner on 25 Dec 09
     
    C++ Command Line Interfaces Standard C++-based implementation. No external dependencies, not even on a runtime library. Any fundamental or user-defined C++ type can be used as an option type. Automatic printing of formatted program usage information. Automatic documentation generation in the HTML and man page formats. Ability to read arguments from the argv array, file, and custom sources. Support for erasing parsed arguments from the argv array. Support for custom option formats. Multi-value option parsing into the std::vector, std::set, and std::map containers. Support for option aliases.
1More

NoSQL Storage Api, NoSQL cloud Api, NoSQL Database Storage Api - 0 views

api.shephertz.com/...storage.php nosql storage api cloud database app42
shared by roberthayes222 on 22 Jan 13 - No Cached
  • NoSQL Storage On the fly database creation for your app on the cloud Store app data in JSON objects at App42 Cloud in Single API call Powerful Query Interface to fetch your stored JSON objects Support of Map Reduce on your stored JSON objects No worries of installation, data disaster and recovery Runs inside scalable and secure App42 platform
19More

Values, Types, and Operators :: Eloquent JavaScript - 0 views

eloquentjavascript.net/01_values.html javascript programming
shared by fspore on 27 Jun 15 - No Cached
  • Not all operators are symbols. Some are written as words. One example is the typeof operator, which produces a string value naming the type of the value you give it.
  • Having such numbers is useful for storing strings inside a computer because it makes it possible to represent them as a sequence of numbers. When comparing strings, JavaScript goes over them from left to right, comparing the numeric codes of the characters one by one.
  • There is only one value in JavaScript that is not equal to itself, and that is NaN, which stands for “not a number”.
  • ...16 more annotations...
  • In practice, you can usually get by with knowing that of the operators we have seen so far, || has the lowest precedence, then comes &&, then the comparison operators (>, ==, and so on), and then the rest. This order has been chosen such that, in typical expressions like the following one, as few parentheses as possible are necessary:
  • The difference in meaning between undefined and null is an accident of JavaScript’s design, and it doesn’t matter most of the time. In the cases where you actually have to concern yourself with these values, I recommend treating them as interchangeable (more on that in a moment).
  • . Yet in the third expression, + tries string concatenation before numeric addition
  • When something that doesn’t map to a number in an obvious way (such as "five" or undefined) is converted to a number, the value NaN is produced.
  • Further arithmetic operations on NaN keep producing NaN, so if you find yourself getting one of those in an unexpected place, look for accidental type conversions.
  • g ==, the outcome is easy to predict: you should get true when both values are the same, except in the case of NaN.
  • But when the types differ, JavaScript uses a complicated and confusing set of rules to determine what to do. In most cases, it just tries to convert one of the values to the other value’s type. However, when null or undefined occurs on either side of the operator, it produces true only if both sides are one of null or undefined.
  • That last piece of behavior is often useful. When you want to test whether a value has a real value instead of null or undefined, you can simply compare it to null with the == (or !=) operator.
  • The rules for converting strings and numbers to Boolean values state that 0, NaN, and the empty string ("") count as false, while all the other values count as true.
  • where you do not want any automatic type conversions to happen, there are two extra operators: === and !==. The first tests whether a value is precisely equal to the other, and the second tests whether it is not precisely equal. So "" === false is false as expected.
  • The logical operators && and || handle values of different types in a peculiar way. They will convert the value on their left side to Boolean type in order to decide what to do, but depending on the operator and the result of that conversion, they return either the original left-hand value or the right-hand value.
  • The || operator, for example, will return the value to its left when that can be converted to true and will return the value on its right otherwise. This conversion works as you’d expect for Boolean values and should do something analogous for values of other types.
  • This functionality allows the || operator to be used as a way to fall back on a default value. If you give it an expression that might produce an empty value on the left, the value on the right will be used as a replacement in that case.
  • The && operator works similarly, but the other way around. When the value to its left is something that converts to false, it returns that value, and otherwise it returns the value on its right.
  • Another important property of these two operators is that the expression to their right is evaluated only when necessary. In the case of true || X, no matter what X is—even if it’s an expression that does something terrible—the result will be true, and X is never evaluated. The same goes for false && X, which is false and will ignore X. This is called short-circuit evaluation.
  • - to negate a number
2More

Home :: Castle Project - 0 views

www.castleproject.org .net aop aspect develop frameworks
shared by Joel Bennett on 08 Feb 07 - Cached
  • Joel Bennett on 08 Feb 07
     
    Castle is an open source project for .net which includes a MVS framework, a data-mapping framework for NHibernate, and an Aspect Oriented Programming framework (Aspect#)
  • anonymous on 27 Sep 13
     
    Visit News www.killdo.de.gg. How to make the 1000 visitor from PR9 backlinks. Buy cheap service www.fiverr.com/radjaseotea/making-best-super-backlink-143445
6More

Joe Duffy's Weblog - OnBeingStateful - 0 views

www.bluebytesoftware.com/...OnBeingStateful.aspx threading Functionallanguages F# STM MultiThreading Frontiers
shared by Matteo Spreafico on 10 Aug 09 - Cached
  • The biggest question left unanswered in my mind is the role state will play in software of the future.
  • The biggest question left unanswered in my mind is the role state will play in software of the future. That seems like an absurd statement, or a naïve one at the very least.  State is everywhere: The values held in memory. Data locally on disk. Data in-flight that is being sent over a network. Data stored in the cloud, including on a database, remote filesystem, etc. Certainly all of these kinds of state will continue to exist far into the future.  Data is king, and is one major factor that will drive the shift to parallel computing.  The question then is how will concurrent programs interact with this state, read and mutate it, and what isolation and synchronization mechanisms are necessary to do so?
  • Many programs have ample gratuitous dependencies, simply because of the habits we’ve grown accustomed to over 30 odd years of imperative programming.  Our education, mental models, books, best-of-breed algorithms, libraries, and languages all push us in this direction.  We like to scribble intermediary state into shared variables because it’s simple to do so and because it maps to our von Neumann model of how the computer works.
  • ...3 more annotations...
  • We need to get rid of these gratuitous dependencies.  Merely papering over them with a transaction—making them “safe”—doesn’t do anything to improve the natural parallelism that a program contains.  It just ensures it doesn’t crash.  Sure, that’s plenty important, but providing programming models and patterns to eliminate the gratuitous dependencies also achieves the goal of not crashing but with the added benefit of actually improving scalability too.  Transactions have worked so well in enabling automatic parallelism in databases because the basic model itself (without transactions) already implies natural isolation among queries.  Transactions break down and scalability suffers for programs that aren’t architected in this way.  We should learn from the experience of the database community in this regard
  • There will always be hidden mutation of shared state inside lower level system components.  These are often called “benevolent side-effects,” thanks to Hoare, and apply to things like lazy initialization and memorization caches.  These will be done by concurrency ninjas who understand locks.  And their effects will be isolated by convention.
  • Even with all of this support, we’d be left with an ecosystem of libraries like the .NET Framework itself which have been built atop a fundamentally mutable and imperative system.  The path forward here is less clear to me, although having the ability to retain a mutable model within pockets of guaranteed isolation certainly makes me think the libraries are salvageable.  Thankfully, the shift will likely be very gradual, and the pieces that pose substantial problems can be rewritten in place incrementally over time.  But we need the fundamental language and type system support first.
5More

Alarming Development : JavaScript is good enough | Jan 2009 - 0 views

alarmingdevelopment.org/?p=191 CLI Java javascript
shared by David Corking on 27 Apr 09 - Cached
  • It is impossible to build a hash table in JavaScript that works on arbitrary objects. You would have to manually allocate unique ID’s for every object and include them in the toString. So no collections in JavaScript. Adobe provides a true built-in hashtable in ActionScript 3.
  • Objects can function as sets and maps. Arrays can function as lists and iterators (generate an array when you need an iterator). More that good enough in this context.
  • VB also often compiles down to better MSIL than C#. It is also the only .NET language with first-class edit-and-continue Lisp-like debugging capabilities.
  • ...1 more annotation...
  • a good collection library should support a meta-object protocol with features like rejecting changes. This allows collections to be passed around as references,
  • David Corking on 27 Apr 09
     
    An old-fashioned language war, 2009 style. Visual Basic even gets a mention as "Lisp-like" (for its debugging.)
5More

JavaScript as a Functional Language | Ajaxonomy | 2009 - 0 views

www.ajaxonomy.com/...cript-as-a-functional-language Functional programming Lisp Web development
shared by David Corking on 09 Apr 09 - Cached
  • there is a little bit of hand-waving involved in calling JavaScript a functional language. JavaScript is not a side-effect free language, nor is it an expression-based language (i.e., it is not value-oriented, but rather variable-oriented). There is no tail call optimization in any of the current implementations, so recursion must be kept shallow. And the list goes on. Truth be told, JavaScript is really one of the first hybrid imperative-functional languages.
  • Higher-order functions allow us to do functional composition,
  • Since JavaScript does not have "overloaded" functions, this type of functionality is usually simulated using manipulation of the function's arguments. Currying comes in handy because it allows you to do this manipulation in a much cleaner and more modular way.
  • ...1 more annotation...
  • Closures have quite a few applications in real-world JavaScript: event binding, callbacks, sorting, mapping (in the classical Lisp sense), and many others. In more modern JavaScript programming, you can find them almost everywhere.
  • David Corking on 09 Apr 09
     
    This is a short tutorial approach to an old but little-noticed saw.
‹ Previous 21 - 40 of 48 Next ›
Showing 20▼ items per page