| Class |
Description |
|
AcceptVerbsAttribute |
Represents an attribute that specifies which HTTP
verbs an action method will respond to. |
|
ActionDescriptor |
Provides information about an action method, such as
its name, controller, parameters, attributes, and filters. |
|
ActionExecutedContext |
Provides the context for the
ActionExecuted method of the
ActionFilterAttribute class. |
|
ActionExecutingContext |
Provides the context for the
ActionExecuting method of the
ActionFilterAttribute class. |
|
ActionFilterAttribute |
Represents the base class for filter attributes. |
|
ActionMethodSelectorAttribute |
Represents an attribute that is used to influence the
selection of an action method. |
|
ActionNameAttribute |
Represents an attribute that is used for the name of
an action. |
|
ActionNameSelectorAttribute |
Represents an attribute that affects the selection of
an action method. |
|
ActionResult |
Encapsulates the result of an action method and is
used to perform a framework-level operation on behalf of the
action method. |
|
AdditionalMetadataAttribute |
Provides a class that implements the
IMetadataAware interface in order to support additional
metadata. |
|
AjaxHelper |
Represents support for rendering HTML in AJAX
scenarios within a view. |
|
AjaxHelper(Of TModel) |
Represents support for rendering HTML in AJAX
scenarios within a strongly typed view. |
|
AjaxRequestExtensions |
Represents a class that extends the
HttpRequestBase class by adding the ability to determine
whether an HTTP request is an AJAX request. |
|
AllowHtmlAttribute |
Allows a request to include HTML markup during model
binding by skipping request validation for the property. (It is
strongly recommended that your application explicitly check all
models where you disable request validation in order to prevent
script exploits.) |
|
AreaRegistration |
Provides a way to register one or more areas in an
ASP.NET MVC application. |
|
AreaRegistrationContext |
Encapsulates the information that is required in order
to register an area within an ASP.NET MVC application. |
|
AssociatedMetadataProvider |
Provides an abstract class to implement a metadata
provider. |
|
AssociatedValidatorProvider |
Provides an abstract class for classes that implement
a validation provider. |
|
AsyncController |
Provides the base class for asynchronous controllers. |
|
AsyncTimeoutAttribute |
Represents an attribute that is used to set the
timeout value, in milliseconds, for an asynchronous method. |
|
AuthorizationContext |
Encapsulates the information that is required for
using an
AuthorizeAttribute attribute. |
|
AuthorizeAttribute |
Represents an attribute that is used to restrict
access by callers to an action method. |
|
BindAttribute |
Represents an attribute that is used to provide
details about how model binding to a parameter should occur. |
|
BuildManagerCompiledView |
Represents the base class for views that are compiled
by the BuildManager class before
being rendered by a view engine. |
|
BuildManagerViewEngine |
Provides a base class for view engines. |
|
ByteArrayModelBinder |
Maps a browser request to a byte array. |
|
ChildActionOnlyAttribute |
Represents an attribute that is used to indicate that
an action method should be called only as a child action. |
|
ChildActionValueProvider |
Represents a value provider for values from child
actions. |
|
ChildActionValueProviderFactory |
Represents a factory for creating value provider
objects for child actions. |
|
ClientDataTypeModelValidatorProvider |
Returns the client data-type model validators. |
|
CompareAttribute |
Provides an attribute that compares two properties of
a model. |
|
ContentResult |
Represents a user-defined content type that is the
result of an action method. |
|
Controller |
Provides methods that respond to HTTP requests that
are made to an ASP.NET MVC Web site. |
|
ControllerActionInvoker |
Represents a class that is responsible for invoking
the action methods of a controller. |
|
ControllerBase |
Represents the base class for all MVC controllers. |
|
ControllerBuilder |
Represents a class that is responsible for dynamically
building a controller. |
|
ControllerContext |
Encapsulates information about an HTTP request that
matches specified
RouteBase and
ControllerBase instances. |
|
ControllerDescriptor |
Encapsulates information that describes a controller,
such as its name, type, and actions. |
|
ControllerInstanceFilterProvider |
Adds the controller to the
FilterProviderCollection instance. |
|
CustomModelBinderAttribute |
Represents an attribute that invokes a custom model
binder. |
|
DataAnnotationsModelMetadata |
Provides a container for common metadata, for the
DataAnnotationsModelMetadataProvider class, and for the
DataAnnotationsModelValidator class for a data model. |
|
DataAnnotationsModelMetadataProvider |
Implements the default model metadata provider for
ASP.NET MVC. |
|
DataAnnotationsModelValidator |
Provides a model validator. |
|
DataAnnotationsModelValidator(Of
TAttribute) |
Provides a model validator for a specified validation
type. |
|
DataAnnotationsModelValidatorProvider |
Implements the default validation provider for ASP.NET
MVC. |
|
DataErrorInfoModelValidatorProvider |
Provides a container for the error-information model
validator. |
|
DefaultControllerFactory |
Represents the controller factory that is registered
by default. |
|
DefaultModelBinder |
Maps a browser request to a data object. This class
provides a concrete implementation of a model binder. |
|
DefaultViewLocationCache |
Represents a memory cache for view locations. |
|
DependencyResolver |
Provides a registration point for dependency resolvers
that implement
IDependencyResolver or the Common Service Locator
IServiceLocator interface. |
|
DependencyResolverExtensions |
Provides a type-safe implementation of
GetService and
GetServices. |
|
DictionaryValueProvider(Of TValue) |
Represents the base class for value providers whose
values come from a collection that implements the
IDictionary(Of TKey, TValue)
interface. |
|
EmptyModelMetadataProvider |
Provides an empty metadata provider for data models
that do not require metadata. |
|
EmptyModelValidatorProvider |
Provides an empty validation provider for models that
do not require a validator. |
|
EmptyResult |
Represents a result that does nothing, such as a
controller action method that returns nothing. |
|
ExceptionContext |
Provides the context for using the
HandleErrorAttribute class. |
|
ExpressionHelper |
Provides a helper class to get the model name from an
expression. |
|
FieldValidationMetadata |
Provides a container for client-side field validation
metadata. |
|
FileContentResult |
Sends the contents of a binary file to the response. |
|
FilePathResult |
Sends the contents of a file to the response. |
|
FileResult |
Represents a base class that is used to send binary
file content to the response. |
|
FileStreamResult |
Sends binary content to the response by using a
Stream instance. |
|
Filter |
Represents a metadata class that contains a reference
to the implementation of one or more of the filter interfaces,
the filter's order, and the filter's scope. |
|
FilterAttribute |
Represents the base class for action and result filter
attributes. |
|
FilterAttributeFilterProvider |
Defines a filter provider for filter attributes. |
|
FilterInfo |
Encapsulates information about the available action
filters. |
|
FilterProviderCollection |
Represents the collection of filter providers for the
application. |
|
FilterProviders |
Provides a registration point for filters. |
|
FormCollection |
Contains the form value providers for the application. |
|
FormContext |
Encapsulates information that is required in order to
validate and process the input data from an HTML form. |
|
FormValueProvider |
Represents a value provider for form values that are
contained in a
NameValueCollection object. |
|
FormValueProviderFactory |
Represents a class that is responsible for creating a
new instance of a form-value provider object. |
|
GlobalFilterCollection |
Represents a class that contains all the global
filters. |
|
GlobalFilters |
Represents the global filter collection. |
|
HandleErrorAttribute |
Represents an attribute that is used to handle an
exception that is thrown by an action method. |
|
HandleErrorInfo |
Encapsulates information for handling an error that
was thrown by an action method. |
|
HiddenInputAttribute |
Represents an attribute that is used to indicate
whether a property or field value should be rendered as a hidden
input element. |
|
HtmlHelper |
Represents support for rendering HTML controls in a
view. |
|
HtmlHelper(Of TModel) |
Represents support for rendering HTML controls in a
strongly typed view. |
|
HttpDeleteAttribute |
Represents an attribute that is used to restrict an
action method so that the method handles only HTTP DELETE
requests. |
|
HttpFileCollectionValueProvider |
Represents a value provider to use with values that
come from a collection of HTTP files. |
|
HttpFileCollectionValueProviderFactory |
Represents a class that is responsible for creating a
new instance of an HTTP file collection value provider object. |
|
HttpGetAttribute |
Represents an attribute that is used to restrict an
action method so that the method handles only HTTP GET requests. |
|
HttpNotFoundResult |
Defines an object that is used to indicate that the
requested resource was not found. |
|
HttpPostAttribute |
Represents an attribute that is used to restrict an
action method so that the method handles only HTTP POST
requests. |
|
HttpPostedFileBaseModelBinder |
Binds a model to a posted file. |
|
HttpPutAttribute |
Represents an attribute that is used to restrict an
action method so that the method handles only HTTP PUT requests. |
|
HttpRequestExtensions |
Extends the
HttpRequestBase class that contains the HTTP values that
were sent by a client during a Web request. |
|
HttpStatusCodeResult |
Provides a way to return an action result with a
specific HTTP response status code and description. |
|
HttpUnauthorizedResult |
Represents the result of an unauthorized HTTP request. |
|
JavaScriptResult |
Sends JavaScript content to the response. |
|
JsonResult |
Represents a class that is used to send JSON-formatted
content to the response. |
|
JsonValueProviderFactory |
Enables action methods to send and receive
JSON-formatted text and to model-bind the JSON text to
parameters of action methods. |
|
LinqBinaryModelBinder |
Maps a browser request to a LINQ
Binary object. |
|
ModelBinderAttribute |
Represents an attribute that is used to associate a
model type to a model-builder type. |
|
ModelBinderDictionary |
Represents a class that contains all model binders for
the application, listed by binder type. |
|
ModelBinderProviderCollection |
Provides a container for model binder providers. |
|
ModelBinderProviders |
Provides a container for model binder providers. |
|
ModelBinders |
Provides global access to the model binders for the
application. |
|
ModelBindingContext |
Provides the context in which a model binder
functions. |
|
ModelClientValidationEqualToRule |
Provides a container for an equality validation rule
that is sent to the browser. |
|
ModelClientValidationRangeRule |
Provides a container for a range-validation rule that
is sent to the browser. |
|
ModelClientValidationRegexRule |
Provides a container for a regular-expression client
validation rule that is sent to the browser. |
|
ModelClientValidationRemoteRule |
Provides a container for a remote validation rule that
is sent to the browser. |
|
ModelClientValidationRequiredRule |
Provides a container for client validation for
required field. |
|
ModelClientValidationRule |
Provides a base class container for a client
validation rule that is sent to the browser. |
|
ModelClientValidationStringLengthRule |
Provides a container for a string-length validation
rule that is sent to the browser. |
|
ModelError |
Represents an error that occurs during model binding. |
|
ModelErrorCollection |
A collection of
ModelError instances. |
|
ModelMetadata |
Provides a container for common metadata, for the
ModelMetadataProvider class, and for the
ModelValidator class for a data model. |
|
ModelMetadataProvider |
Provides an abstract base class for a custom metadata
provider. |
|
ModelMetadataProviders |
Provides a container for the current
ModelMetadataProvider instance. |
|
ModelState |
Encapsulates the state of model binding to a property
of an action-method argument, or to the argument itself. |
|
ModelStateDictionary |
Represents the state of an attempt to bind a posted
form to an action method, which includes validation information. |
|
ModelValidationResult |
Provides a container for a validation result. |
|
ModelValidator |
Provides a base class for implementing validation
logic. |
|
ModelValidatorProvider |
Provides a list of validators for a model. |
|
ModelValidatorProviderCollection |
Provides a container for a list of validation
providers. |
|
ModelValidatorProviders |
Provides a container for the current validation
provider. |
|
MultiSelectList |
Represents a list of items that users can select more
than one item from. |
|
MvcFilter |
When implemented in a derived class, provides a
metadata class that contains a reference to the implementation
of one or more of the filter interfaces, the filter's order, and
the filter's scope. |
|
MvcHandler |
Selects the controller that will handle an HTTP
request. |
|
MvcHtmlString |
Represents an HTML-encoded string that should not be
encoded again. |
|
MvcHttpHandler |
Verifies and processes an HTTP request. |
|
MvcRouteHandler |
Creates an object that implements the
IHttpHandler interface and passes the
request context to it. |
|
MvcWebRazorHostFactory |
Creates instances of
MvcWebPageRazorHost files. |
|
NameValueCollectionExtensions |
Extends a NameValueCollection
object so that the collection can be copied to a specified
dictionary. |
|
NameValueCollectionValueProvider |
Represents the base class for value providers whose
values come from a
NameValueCollection object. |
|
NoAsyncTimeoutAttribute |
Provides a convenience wrapper for the
AsyncTimeoutAttribute attribute. |
|
NonActionAttribute |
Represents an attribute that is used to indicate that
a controller method is not an action method. |
|
OutputCacheAttribute |
Represents an attribute that is used to mark an action
method whose output will be cached. |
|
ParameterBindingInfo |
Encapsulates information for binding action-method
parameters to a data model. |
|
ParameterDescriptor |
Contains information that describes a parameter. |
|
PartialViewResult |
Represents a base class that is used to send a partial
view to the response. |
|
PreApplicationStartCode |
Provides a registration point for ASP.NET Razor
pre-application start code. |
|
QueryStringValueProvider |
Represents a value provider for query strings that are
contained in a
NameValueCollection object. |
|
QueryStringValueProviderFactory |
Represents a class that is responsible for creating a
new instance of a query-string value-provider object. |
|
RangeAttributeAdapter |
Provides an adapter for the
RangeAttribute attribute. |
|
RazorView |
Represents the class used to create views that have
Razor syntax. |
|
RazorViewEngine |
Represents a view engine that is used to render a Web
page that uses the ASP.NET Razor syntax. |
|
RedirectResult |
Controls the processing of application actions by
redirecting to a specified URI. |
|
RedirectToRouteResult |
Represents a result that performs a redirection by
using the specified route values dictionary. |
|
ReflectedActionDescriptor |
Contains information that describes a reflected action
method. |
|
ReflectedControllerDescriptor |
Contains information that describes a reflected
controller. |
|
ReflectedParameterDescriptor |
Contains information that describes a reflected
action-method parameter. |
|
RegularExpressionAttributeAdapter |
Provides an adapter for the
RegularExpressionAttribute attribute. |
|
RemoteAttribute |
Provides an attribute that uses the jQuery validation
plug-in remote validator. |
|
RequiredAttributeAdapter |
Provides an adapter for the
RequiredAttributeAttribute attribute. |
|
RequireHttpsAttribute |
Represents an attribute that forces an unsecured HTTP
request to be re-sent over HTTPS. |
|
ResultExecutedContext |
Provides the context for the
OnResultExecuted method of the
ActionFilterAttribute class. |
|
ResultExecutingContext |
Provides the context for the
OnResultExecuting method of the
ActionFilterAttribute class. |
|
RouteCollectionExtensions |
Extends a
RouteCollection object for MVC routing. |
|
RouteDataValueProvider |
Represents a value provider for route data that is
contained in an object that implements the
IDictionary(Of TKey, TValue)
interface. |
|
RouteDataValueProviderFactory |
Represents a factory for creating route-data value
provider objects. |
|
SelectList |
Represents a list that lets users select one item. |
|
SelectListItem |
Represents the selected item in an instance of the
SelectList class. |
|
SessionStateAttribute |
Specifies the session state of the controller. |
|
SessionStateTempDataProvider |
Provides session-state data to the current
TempDataDictionary object. |
|
StringLengthAttributeAdapter |
Provides an adapter for the
StringLengthAttribute attribute. |
|
TempDataDictionary |
Represents a set of data that persists only from one
request to the next. |
|
TemplateInfo |
Encapsulates information about the current template
context. |
|
UrlHelper |
Contains methods to build URLs for ASP.NET MVC within
an application. |
|
UrlParameter |
Represents an optional parameter that is used by the
MvcHandler class during routing. |
|
ValidatableObjectAdapter |
Provides an object adapter that can be validated. |
|
ValidateAntiForgeryTokenAttribute |
Represents an attribute that is used to prevent
forgery of a request. |
|
ValidateInputAttribute |
Represents an attribute that is used to mark action
methods whose input must be validated. |
|
ValueProviderCollection |
Represents the collection of value-provider objects
for the application. |
|
ValueProviderDictionary |
Obsolete. Represents a dictionary of
value providers for the application. |
|
ValueProviderFactories |
Represents a container for value-provider factory
objects. |
|
ValueProviderFactory |
Represents a factory for creating value-provider
objects. |
|
ValueProviderFactoryCollection |
Represents the collection of value-provider factories
for the application. |
|
ValueProviderResult |
Represents the result of binding a value (such as from
a form post or query string) to an action-method argument
property, or to the argument itself. |
|
ViewContext |
Encapsulates information that is related to rendering
a view. |
|
ViewDataDictionary |
Represents a container that is used to pass data
between a controller and a view. |
|
ViewDataDictionary(Of TModel) |
Represents a container that is used to pass strongly
typed data between a controller and a view. |
|
ViewDataInfo |
Encapsulates information about the current template
content that is used to develop templates and about HTML helpers
that interact with templates. |
|
ViewEngineCollection |
Represents a collection of view engines that are
available to the application. |
|
ViewEngineResult |
Represents the result of locating a view engine. |
|
ViewEngines |
Represents a collection of view engines that are
available to the application. |
|
ViewMasterPage |
Represents the information that is needed to build a
master view page. |
|
ViewMasterPage(Of TModel) |
Represents the information that is required in order
to build a strongly typed master view page. |
|
ViewPage |
Represents the properties and methods that are needed
to render a view as a Web Forms page. |
|
ViewPage(Of TModel) |
Represents the information that is required in order
to render a strongly typed view as a Web Forms page. |
|
ViewResult |
Represents a class that is used to render a view by
using an IView instance that is returned by an
IViewEngine object. |
|
ViewResultBase |
Represents a base class that is used to provide the
model to the view and then render the view to the response. |
|
ViewStartPage |
Provides an abstract class that can be used to
implement a view start (master) page. |
|
ViewTemplateUserControl |
Provides a container for
TemplateInfo objects. |
|
ViewTemplateUserControl(Of TModel) |
Provides a container for
TemplateInfo objects. |
|
ViewType |
Represents the type of a view. |
|
ViewUserControl |
Represents the information that is needed to build a
user control. |
|
ViewUserControl(Of TModel) |
Represents the information that is required in order
to build a strongly typed user control. |
|
VirtualPathProviderViewEngine |
Represents an abstract base-class implementation of
the
IViewEngine interface. |
|
WebFormView |
Represents the information that is needed to build a
Web Forms page in ASP.NET MVC. |
|
WebFormViewEngine |
Represents a view engine that is used to render a Web
Forms page to the response. |
|
WebViewPage |
Represents the properties and methods that are needed
in order to render a view that uses ASP.NET Razor syntax. |
|
WebViewPage(Of TModel) |
Represents the properties and methods that are needed
in order to render a view that uses ASP.NET Razor syntax. |


--- layout: post title: Blogging as a bridge between academia and public sphere date: 2011-09-02 09:49:40.000000000 -04:00 categories: - Commentary on works - Economics - International Relations - Social Science tags: [] status: publish type: post published: true meta: _edit_last: '7106425' author: login: samarthbhaskar email<EMAIL_ADDRESS>display_name: samarthbhaskar first_name: '' last_name: '' ---
Harvard political scientist Stephen Walt wrote an essay on the role of international affairs academics in the public sphere. Not the first of its kind of course, but this essay is a pretty thorough description of the state of the two arenas (academia and policy/public sphere) and how they do not co-exist nearly as much as they should. Walt is speaking as an international relations scholar, but his complaints and recommendations could probably span across academic disciplines (perhaps with the exception of the natural sciences, since people don't have as many intuitions about how quantum mechanics or gene therapy works on which to base their biases).
The essay is worth a read, if for no other reason, to get an idea of the relationship between the academy and the public sphere over the course of modern history. Among the many suggestions Walt outlines to remedy this broken relationship, he suggests that popular writing (op-eds, articles in newspapers and magazines, blogs, etc) should not be looked down upon within the academy. On the suggestion of blogs, this working paper [PDF] by the World Bank comes to mind. In it, the impact of popular economics blogs is assessed through various experimental and non-experimental means.
The paper offers 3 main take-aways:
- Links from blogs cause a striking increase in abstract views or downloads of economics papers.
- Blogging raises the profile of the blogger (and his or her institution) and boosts their reputation above economists with similar publication records.
- Blogs can transform attitudes about some of the topics they cover.


Surname
First Name
Middle name
You are male female
Age
Country of Residence
City Ryazan Moscow
Photography
Title Web Master Database Administrator Computer-aided design Economic Planning Management accounting Budgeting and planning
Salary
Site
Email
Phone


forms-angular is a simple framework build on top of the MEAN stack (with a little Twitter Bootstrap and Mongoose thrown in for good measure) that enables you to generate forms super quickly. At its simplest it takes a mongoose schema and generates a form, complete with REST routing and bindings.
You can have your first forms-angular application running in a few minutes using the Yeoman generator. Once the generator is installed yo fng is all it takes to get you up and running - see the Getting Started page for details.
Forms-angular is easy to extend, using regular Angular JS controllers that allow you to hook into navigation elements, data events and much more. It also comes with a number of plugins that extend the base functionality, adding reporting, full featured editors and much much more!


| [ Team LiB ] |
17.4 Optimization"First make it work. Then make it right. Then make it fast." This quotation, often with slight variations, is widely known as the golden rule of programming. As far as I've been able to ascertain, the quotation is attributed to Kent Beck, who credits his father with it. Being widely known makes the principle no less important, particularly because it's more honored in the breach than in the observance. A negative form, slightly exaggerated for emphasis, is in a quotation by Don Knuth: "Premature optimization is the root of all evil in programming." Optimization is premature if your code is not working yet. First make it work. Optimization is also premature if your code is working but you are not satisfied with the overall architecture and design. Remedy structural flaws before worrying about optimization: first make it work, then make it right. These first two steps are not optional—working, well-architected code is always a must. In contrast, you don't always need to make it fast. Benchmarks may show that your code's performance is already acceptable after the first two steps. When performance is not acceptable, profiling often shows that all performance issues are in a small subset, perhaps 10% to 20% of the code where your program spends 80% or 90% of the time. Such performance-crucial regions of your code are also known as its bottlenecks, or hot spots. It's a waste of effort to optimize large portions of code that account for, say, 10% of your program's running time. Even if you made that part run 10 times as fast (a rare feat), your program's overall runtime would only decrease by 9%, a speedup no user will even notice. If optimization is needed, focus your efforts where they'll matter, on bottlenecks. You can optimize bottlenecks while keeping your code 100% pure Python. In some cases, you can resort to recoding some computational bottlenecks as Python extensions, potentially gaining even better performance. 17.4.1 Developing a Fast-Enough Python ApplicationStart by designing, coding, and testing your application in Python, often using some already available extension modules. This takes much less time than it would take with a classic compiled language. Then benchmark the application to find out if the resulting code is fast enough. Often it is, and you're done—congratulations! Since much of Python itself is coded in highly optimized C, as are many of its standard and extension modules, your application may even turn out to be already faster than typical C code. However, if the application is too slow, you need to re-examine your algorithms and data structures. Check for bottlenecks due to application architecture, network traffic, database access, and operating system interactions. For typical applications, each of these factors is more likely than language choice to cause slowdowns. Tinkering with large-scale architectural aspects can often speed up an application dramatically, and Python is an excellent medium for such experimentation. If your program is still too slow, you should profile it to find out where the time is going. Applications often exhibit computational bottlenecks—small areas of the source code, generally between 10% and 20%, which account for 80% or more of the running time. You can now optimize the bottlenecks, applying the techniques suggested in the rest of this chapter. If normal Python-level optimizations still leave some outstanding computational bottlenecks, you can recode them as Python extension modules, as covered in Chapter 24. In the end, your application will run at roughly the same speed as if you had coded it all in C, C++, or Fortran—or faster, when large-scale experimentation has let you find a better architecture. Your overall programming productivity with this process is not much less than if you coded everything in Python. Future changes and maintenance are easy, since you use Python to express the overall structure of the program, and lower-level, harder-to-maintain languages only for a few specific computational bottlenecks. As you produce applications in a given area according to this process, you will accumulate a library of reusable Python extension modules for that area. You therefore become more and more productive at developing other fast-running Python applications in the same field. Even if external constraints should eventually force you to recode the whole application in a lower-level language, you're still better off for having started in Python. Rapid prototyping has long been acknowledged as the best way to get a software architecture just right. A working prototype lets you check that you have identified the right problems and taken the best path to their solution. A prototype affords the kind of large-scale architectural experimentation that can make a real difference to performance. Starting your prototype with Python allows a gradual migration to other languages by way of extension modules. The application remains in a fully functional and testable state at each stage. This ensures against the risk of compromising a design's architectural integrity in the coding stage. The resulting software is likely to be faster and more robust than if all of the coding had been lower-level from the start, and your productivity, while not quite as good as with a pure Python or mostly Python application, is still better than if you had been coding at a lower level throughout. 17.4.2 BenchmarkingBenchmarking is similar to system testing: both activities are like running the program as it's meant to be run for production purposes. In both cases, you need to have at least some subset of the program's intended functionality working, and you need to use known, reproducible inputs. In the case of benchmarking, you don't need to capture and check your program's output: since you make it work and make it right before you make it fast, you are already confident about your program's correctness by the time you benchmark it. You do need inputs that are representative of typical system operations, particularly those that may be most challenging for your program's performance. If your program performs several kinds of operations, make sure you run one or two benchmarks for each different kind of operation. Elapsed time as measured by your wristwatch is probably precise enough to benchmark most programs. Programs with hard real-time constraints are obviously another matter, but they have needs very different from those of normal programs in most respects. A 5% or 10% difference in performance, except for programs with very peculiar constraints, makes no practical difference to a program's real-life usability. When you benchmark "toy" programs in order to help you choose an algorithm or data structure, you may need more precision. In that case, you may want to set up an artificial environment, with a machine as quiescent as possible, no network activity, and accurate timekeeping. Python time operations are covered in Chapter 12. The benchmarking discussed in this section is a different kind of issue: an approximation of real-life program operation, for the sole purpose of checking whether the program's performance at each task is acceptable, before embarking on profiling and other optimization activities. For such system benchmarking, a situation that approximates the program's normal operating conditions is best, and accuracy in timing is not particularly important. 17.4.3 Large-Scale OptimizationThe aspects of your program that are most important for performance are large-scale ones: choice of algorithms, overall architecture, and choice of data structures. The performance issues that you must almost always take into account are those connected with the traditional big-O notation of computer science. Informally, if you call N the input size of an algorithm, big-O notation expresses algorithm performance, for large values of N, as proportional to a function of N (in precise computer science lingo, this should actually be called big-Theta, but in practical use programmers in the field call this big-O). An O(N) algorithm is one where, for large enough N, handling twice as much data takes about twice as much time, three times as much data three times as much time, and so on, growing linearly with N. An O(N2) algorithm is one where, for large enough N, handling twice as much data takes about four times as much time, three times as much data nine times as much time, and so on, growing with N squared. You will find more information on big-O notation, as well as other issues about algorithms and their complexity, in any good book about algorithms and data structures. Unfortunately, at the time of this writing, there aren't yet any such books using Python. However, if you are at least moderately familiar with C, I can recommend Mastering Algorithms with C, by Kyle Loudon (O'Reilly). To understand the practical importance of big-O considerations in your programs, consider two different ways to accept all items from an input iterator and accumulate them into a list in reverse order: def slow(it): result = [ ] for item in it: result.insert(0, item) return result def fast(it): result = [ ] for item in it: result.append(item) result.reverse( ) return result We could express each of these functions more concisely, but the key difference is best appreciated by presenting them in these elementary terms. Function slow builds the result list by inserting each input item before all previously received ones. Function fast appends each input item after all previously received ones, then reverses the result list just before returning it. Intuitively, one might think that the final reversing represents extra work, and therefore slow should be faster than fast. But that's not the way things work out. Each call to result.append takes roughly the same amount of time, independent of how many items are already in list result, since there is always a free slot for an extra item at the end of the list. The for loop in function fast executes N times to receive N items. Since each iteration of the loop takes a constant time, overall loop time is O(N). result.reverse also takes time O(N), as it is directly proportional to the total number of items. Thus, the total running time of fast is also O(N). (If you don't understand why a sum of two quantities, each O(N), is also O(N), consider that the sum of two linear functions of N is also a linear function of N). In contrast, each call to result.insert must make space at slot 0 for the new item to insert, by moving all items that are already in list result forward one slot. That takes a time proportional to the number of items that are already in the list. The overall amount of time to receive N items is therefore proportional to 1+2+3+...N-1, a sum whose value is O(N2). Therefore, the total running time of slow is also O(N2). It's almost always worth replacing an O(N2) solution with an O(N) one, unless you can somehow assign rigorous limits to the input size N. If N can grow without bounds, the O(N2) solution will inevitably turn out to be disastrously slower than the O(N) one for large enough values of N, no matter what the proportionality constants in each case may be (and no matter what profiling tells you). Unless you have other O(N2) or even worse bottlenecks elsewhere that you cannot eliminate, a part of the program that is O(N2) will inevitably turn into the program's bottleneck and dominate runtime for large enough values of N. Do yourself a favor and watch out for the big O: all other performance issues, in comparison, are insignificant. Incidentally, function fast can be made substantially faster by expressing it in more idiomatic Python. Just replace the first two lines with the single statement: result = list(it) This change does not affect fast's big-O character (fast is still O(N) after the change), but does speed things up by a constant factor. Often, in Python, the simplest, clearest, most idiomatic way to express something is also the fastest. Choosing algorithms with good big-O characteristics is roughly the same task in Python as in any other language. You just need a few indications about the big-O performance of Python's elementary building blocks. <IP_ADDRESS> List operationsPython lists are internally implemented with vectors (also known as arrays), not with linked lists. This fundamental implementation choice determines just about all performance characteristics of Python lists, in big-O terms. Chaining two lists of length N1 and N2 is O(N1+N2). Multiplying a list of length N by the number M is O(N*M). Accessing or rebinding any list item is O(1) (also known as constant time, meaning that the time taken does not depend on how many items are in the list). len( ) on a list is also O(1). Accessing any slice of length M is O(M). Rebinding a slice of length M with one of identical length is also O(M). Rebinding a slice of length M1 with one of different length M2 is O(M1+M2+N1), where N1 is the number of items after the slice in the target list. Most list methods, as shown way back in Table 4-3, are equivalent to slice rebindings and have the same big-O performance. Methods count, index, remove, and reverse, and operator in, are O(N). Method sort is generally O(N*log(N)), but has optimizations that let it be O(N) in some important special cases, like when the list is already sorted, reverse sorted, or sorted except for a few items at the end (in Python 2.3, sort will also be O(N) in a few more important special cases). range(a,b,c) is O((b-a)/c). xrange(a,b,c) is O(1), but looping on xrange's result is O((b-a)/c). <IP_ADDRESS> String operationsMost methods on a string of length N (be it plain or Unicode) are O(N). len(astring) is O(1). The fastest way to produce a copy of a string with transliterations and/or removal of specified characters is the string's method translate. The most practically important big-O consideration involving strings is covered in Section 17.4.5 later in this chapter. <IP_ADDRESS> Dictionary operationsPython dictionaries are internally implemented with hash tables. This fundamental implementation choice determines just about all performance characteristics of Python dictionaries, in big-O terms. Accessing, rebinding, adding, or removing a dictionary item is generally O(1), as are methods has_key, get, setdefault, and popitem, and operator in. d1.update(d2) is O(len(d2)). len(adict) is O(1). Methods keys, items, and values are O(N). Methods iterkeys, iteritems, and itervalues are O(1), but looping on the iterators that those methods return is O(N). When the keys in a dictionary are instances of classes that define _ _hash_ _ and equality comparison methods, dictionary performance is of course affected by those methods. The indications presented in this paragraph are valid only if both hashing and equality comparison are O(1). 17.4.4 ProfilingMost programs have hot spots (i.e., regions of source code that account for most of the time elapsed during a program run). Don't try to guess where your program's hot spots are; programmers' intuition is notoriously unreliable in this field. Use module profile to collect profile data over one or more runs of your program, with known inputs. Then, use module pstats to collate, interpret, and display that profile data. To gain accuracy, you can calibrate the Python profiler for your machine (i.e., determine what overhead profiling incurs on your machine). Module profile can then subtract this overhead from the times it measures so that the profile data you collect is closer to reality. <IP_ADDRESS> The profile moduleThe profile module supplies one function you will often use.
code is a string such as you could use with statement exec, normally a call to the main function of the program you're profiling. filename is the path of a file that run creates or rewrites with profile data. Usually you call run a few times, specifying different filenames, and possibly different arguments to your program's main function, in order to exercise various program parts proportionately. Then, you use module pstats to display collated results. You may call run without a filename to obtain a summary report, similar to the one module pstats could give you, directly on standard output. However, this approach gives no control at all over output format, nor does it offer any way to consolidate several runs into one report. In practice, you rarely use this feature: collecting profile data into files is generally preferable. Module profile also supplies class Profile, mentioned in the next section. By instantiating Profile directly, you can access advanced functionality, such as the ability to run a command in specified local and global dictionaries. I do not cover such advanced functionality of class profile.Profile further in this book. <IP_ADDRESS> CalibrationTo calibrate profile for your machine, you need to use class Profile, which module profile supplies and internally uses in function run. An instance p of Profile supplies one method you use for calibration.
Loops N times, then returns a number that is the profiling overhead per call on your machine. N must be large if your machine is fast. Call p.calibrate(10000) a few times and check that the various numbers it returns are very close to each other, then pick the smallest one of them. If the numbers exhibit substantial variation, try again with larger values of N. The calibration procedure can be time consuming. However, you need to perform it only once, repeating it only when you make changes that could alter your machine's characteristics, such as applying patches to your operating system, adding memory, or changing Python version. Once you know your machine's overhead, you can tell profile about it each time you import it, right before using profile.run. The simplest way to do this is as follows: import profile profile.Profile.bias = ...the overhead you measured... profile.run('main( )', 'somefile') <IP_ADDRESS> The pstats moduleThe pstats module supplies a single class, Stats, that you use to analyze, consolidate, and report on the profile data contained in one or more files written by function profile.run.
Instantiates Stats with one or more filenames of files of profile data written by function profile.run. An instance s of class Stats provides methods to add profile data and sort and output results. Each method returns s, so you can chain several calls in the same expression. s's main methods are as follows.
Adds another file of profile data to the set that s is holding for analysis.
Outputs the list of functions in s's profile data, sorted according to the latest call to s.sort_stats, and subject to the given restrictions, if any. You can call each printing method with zero or more restrictions, which are applied one after the other, in order, to reduce the number of output lines. A restriction that is an integer n limits the output to the first n lines. A restriction that is a floating-point value f between 0.0 and 1.0 limits the output to a fraction f of the lines. A restriction that is a string is compiled as a regular expression (as covered in Chapter 9); only lines satisfying a search method call on the regular expressions are output. Restrictions are cumulative. For example, s.print_calls(10,0.5) outputs the first 5 lines (half of 10). Output restrictions apply only after the summary and header lines: summary and header are output unconditionally. Each function f that is output is accompanied by the list of f's callers (the functions that called f) or f's callees (the functions that f called) according to the name of the method.
Outputs statistics about s's profile data, sorted according to the latest call to s.sort_stats, and subject to the given restrictions, if any, as covered in print_callees. After a few summary lines (date and time on which profile data was collected, number of function calls, and sort criteria used), the output, absent restrictions, is one line per function, with six fields per line, labeled in a header line. For each function f, print_stats outputs six fields:
Gives one or more keys (primary first, if more than one) on which to sort future output. Each key is a string. The sort is descending for keys indicating times or numbers, alphabetical (ascending) for key 'nfl'. The most frequently used keys when calling sort_stats are:
Alters s by stripping directory names from all the module names that s holds, to make future output more compact. s is unsorted after s.strip_dirs( ), and therefore you normally call s.sort_stats with the arguments you desire right after calling s.strip_dirs. 17.4.5 Small-Scale OptimizationFine tuning of program operations is rarely important. Such tuning may make a small but meaningful difference in some particularly hot spot, but hardly ever is it a decisive factor. And yet, such fine tuning, in the pursuit of mostly irrelevant microefficiencies, is where a programmer's instincts are likely to lead. It is in good part because of this that most optimization is premature and best avoided. The most that can be said in favor of fine tuning is that, if one idiom is always speedier than another when the difference is measurable, it's worth getting into the habit of always using the former and not the latter. Most often, in Python, if you do what comes naturally and choose simplicity and elegance, you end up with code that has good performance as well as clarity and maintainability. In a few cases, an approach that may not be intuitive offers performance advantages, as discussed in the rest of this section. The simplest possible optimization is to run your Python programs using python -O or -OO. -OO makes little direct difference to performance compared to -O, but -OO may save memory, since it removes docstrings from the bytecode, and memory availability is sometimes (indirectly) a performance bottleneck. The optimizer is not very powerful in current releases of Python, but it may still gain you performance advantages on the order of 10%, sometimes as large as 20% (potentially even larger, if you make heavy use of assert statements and if _ _debug_ _: guards as suggested in Chapter 6). The best aspect of -O is that it costs nothing—as long as your optimization isn't premature, of course. -O does impede use of debuggers, such as pdb, and may thus make debugging somewhat harder if your program isn't fully tested and working correctly. So, don't use -O on a program you're still developing. <IP_ADDRESS> Building up a string from piecesThe single Python anti-idiom that's likeliest to kill your program's performance, to the point that you should never use it, is to build up a large string from pieces by looping on string concatenation statements such as big_string+=piece. Since Python strings are immutable, such a concatenation makes Python free the M bytes previously allocated for big_string, and allocate and fill M+K bytes for the new version. Doing this repeatedly in a loop, you end up with roughly O(N2) performance, where N is the total number of characters. More often than not, O(N2) performance where O(N) is available is a performance disaster. On some platforms, things may be even bleaker due to memory fragmentation effects caused by freeing many memory areas, all of different sizes, and allocating progressively larger ones. To achieve O(N) performance, accumulate intermediate pieces in a list rather than building up the string piece by piece. Lists, unlike strings, are mutable, so appending to a list has O(1) performance (amortized). Change each occurrence of big_string+=piece into temp_list.append(piece). Then, when you're done accumulating, use the following to build your desired string result in O(N) time: big_string = ''.join(temp_list) Other O(N) ways to build up big strings are to concatenate the pieces to an instance of array.array('c'), or to write the pieces to an instance of cStringIO.StringIO. In the special case where you want to output the resulting string, you may gain a further small slice of performance by using writelines on temp_list (never building big_string in memory). When feasible (i.e., when you have the output file object open and available in the loop), it's at least as effective to perform a write call for each piece, without any accumulation. Although not nearly as crucial as += on a big string in a loop, another case where removing string concatenation may give a slight performance improvement is when you're concatenating several values in an expression: oneway = str(x)+' eggs and '+str(y)+' slices of '+k+' ham' another = '%s eggs and %s slices of %s ham' % (x, y, k) Using operator % for string formatting is often a good performance choice. <IP_ADDRESS> Searching and sortingOperator in, the most natural tool for searching, is O(1) when the right-hand side operand is a dictionary, but O(N) when the right-hand side operand is a list. If you need to perform many searches on a container, you're generally much better off using a dictionary, rather than a list, as the container. Python dictionaries are highly optimized for searching and fetching items by key. Method sort of Python lists is also a highly optimized and sophisticated tool. You can rely on sort's performance. Performance dramatically degrades, however, if you pass sort a custom callable to perform comparisons in order to sort a list based on anything but built-in comparisons. To satisfy such needs, consider using the decorate-sort-undecorate (DSU) idiom instead. This idiom has the following steps:
The decorate and undecorate steps are most often handily performed with list comprehensions. If you need the sort to be in-place, assign the final sorted list to L[:]. Otherwise, DSU provides a sorted copy, without disturbing the original list L. For example, say we have in L a large list of strings, each of at least two words, and we want to sort L in-place by the second word of each string: A = [ (s.split( )[1], s) for s in L ] A.sort( ) L[:] = [ t[1] for t in A ] This is much faster than passing to L.sort a function that compares two strings by their second words, as in: def cmp2ndword(a, b): return cmp(a.split( )[1], b.split( )[1]) L.sort(cmp2ndword) On a series of benchmarks with Python 2.2 on lists of 10,000 strings, I measured the DSU version as 7 to 10 times faster than the non-DSU one. <IP_ADDRESS> Avoiding exec and from ... import *If a function contains an exec statement without explicit dictionaries, the whole function slows down substantially. The presence of such an exec statement forces the Python compiler to avoid the modest but precious optimizations it normally performs because such an exec might cause any alteration at all to the function's namespace. A from statement of the form: from MyModule import * causes similar performance loss, since it, too, can alter a function's namespace unpredictably. exec itself is also quite slow, particularly if you apply it to a string of source code rather than to a code object. By far the best approach, for performance, for correctness, and for clarity, is to avoid exec altogether. It's most often possible to find better (faster, more solid, and clearer) solutions. If you must use exec, always use it with explicit dictionaries. If you need to exec a dynamically obtained string more than once, compile the string one time and repeatedly exec the resulting code object. eval works on expressions, not on statements; therefore, although it's still slow, at least it avoids some of the worst performance impacts of exec. With eval, too, you're best advised to use explicit dictionaries, and, if you need repeated evaluation of the same dynamically obtained string, compile the string just once, then repeatedly eval the resulting code object. <IP_ADDRESS> Optimizing loopsMost of your program's bottlenecks will be in loops, particularly nested loops, because loop bodies often execute repeatedly. Python does not implicitly perform any code hoisting: if you have any code inside a loop that might be executed just once by hoisting it out of the loop, and the loop is a performance bottleneck, hoist the code out yourself. Sometimes the presence of code to hoist may not be immediately obvious: def slower(anobject, ahugenumber): for i in xrange(ahugenumber): anobject.amethod(i) def faster(anobject, ahugenumber): themethod = anobject.amethod for i in xrange(ahugenumber): themethod(i) In this case, the code that faster hoists out of the for loop is the attribute lookup anobject.amethod. slower repeats the lookup each and every time, while faster performs it just once. The two functions are not 100% equivalent: it is (just barely) conceivable that executing amethod might cause such changes on anobject that the next lookup for the same named attribute fetches a different method object. This is part of why Python doesn't perform such optimizations itself. In practice, such subtle, obscure, and tricky cases happen far less than one time in ten thousand. So you're quite safe performing such optimizations yourself, when you're trying to squeeze the last drop of performance out of some crucial bottleneck. It's faster for Python to use local variables than global ones. So, if one of your loops is repeatedly accessing a global variable whose value does not change between iterations of the loop, put the value in a local variable and have the loop access the local variable instead. This also applies to built-in functions: def slightly_slower(asequence, adict): for x in asequence: adict[x] = hex(x) def slightly_faster(asequence, adict): myhex = hex for x in asequence: adict[x] = myhex(x) Here, the speedup is very modest, on the order of 5% or so. Do not cache None. None is currently an ordinary built-in identifier, but it is scheduled to become a keyword in Python 2.3 or 2.4, so no further optimization will be needed. List comprehensions can be faster than loops, and so can map and filter. For optimization purposes, try changing loops into list comprehensions or map and filter calls where feasible. However, the performance advantage of map and filter is nullified if you have to use a lambda or an extra level of function call. Only when you pass to map or filter a built-in function, or a function you'd have to call anyway even from an explicit loop, do you stand to gain. The loops that you can replace most naturally with list comprehensions, or map and filter calls, are loops that build up a list by repeatedly calling append on the list. In such cases, if you know in advance the length of the resulting list, a further optimization is available. Predefine the result list to the right length (e.g., with result=[None]*N), introduce an explicit index i that starts at 0 and grows by one at each iteration of the loop, and change each call to result.append(x) into result[i]=x. The following example shows this optimization in the context of a typical microperformance benchmark script: import time def slow(asequence): result = [ ] for x in asequence: result.append(-x) return result def middling(asequence): return [ -x for x in asequence ] def fast(asequence): result = [None]*len(asequence) for i in xrange(len(asequence)): result[i] = -asequence[i] return result biggie = xrange(500*1000) tentimes = [None]*10 def timit(afunc): lobi = biggie start = time.clock( ) for x in tentimes: afunc(lobi) stend = time.clock( ) return "%-10s: %.2f" % (afunc._ _name_ _, stend-start) for afunc in slow, middling, fast, fast, middling, slow: print timit(afunc) Running this example with python -O (on a PC with a 1.2 GHz Athlon CPU, Python 2.2.1) shows fast taking 4.30 seconds, middling 4.81 to 4.84 seconds, and slow 6.50 to 7.02 seconds, on Windows 98. The time ranges on Linux are 4.19- 4.20, 5.15-5.20, and 6.91-7.00, respectively. With the current alpha version of Python 2.3 on Linux, the time ranges are 3.35-3.37 for fast, 4.61-4.64 for middling, and 6.43-6.44 for slow. In summary, on this machine, slow is 35%-40% slower than middling, and middling is about 15%-25% slower than fast (and Python 2.2 is 10%-25% slower than the current alpha of Python 2.3). <IP_ADDRESS> Optimizing I/OIf your program does substantial amounts of I/O, it's likely that performance bottlenecks are due to I/O, not to computation. Such programs are said to be I/O bound, rather than CPU bound. Your operating system tries to optimize I/O performance, but you can help it in a couple of ways. One such way is to perform your I/O in chunks of a size that is optimal for performance, rather than simply being convenient for your program's operations. Another way is to use threading. From the point of view of a program's convenience and simplicity, the ideal amount of data to read or write at a time is generally small (one character or one line) or very large (an entire file at a time). That's often okay, because Python and your operating system work behind the scenes to let your program use convenient logical chunks for I/O, while arranging physical I/O operations with chunk sizes that are more attuned to performance. Reading and writing a whole file at a time is quite likely to be okay for performance as long as the file is not inordinately large. Specifically, file-at-a-time I/O is fine as long as the file's data fits in your machine's physical memory, leaving enough physical memory available for your program and operating system to perform whatever other tasks they need to perform at the same time. The hard problems of I/O-bound program performance tend to come with huge files. If performance is an issue, don't use a file object's readline method, which is limited in the amount of chunking and buffering it can perform. Using writeline, on the other hand, gives no performance problem when that method is the one most convenient for your program. Loop directly on the file object (in Python 2.2) to get one line at a time with the best performance. If the file isn't too huge, time two versions of your program, one that loops directly on the file object and one that calls method readlines, which reads the whole file into memory. Either solution may prove faster. In Python 2.1, you can't loop directly on the file object. Instead, use method xreadlines in a for loop. xreadlines will be deprecated in Python 2.3, but if you need top performance in this specific case and need to support Python 2.1, there is no alternative. For binary files, specifically large binary files of whose contents you need just a part on each run of your program, module mmap, covered in Chapter 14, can often give you both good performance and program simplicity. Making an I/O-bound program multithreaded may sometimes afford substantial performance gains if you can arrange your program's architecture accordingly. Start a few worker threads devoted exclusively to I/O, have the computational threads request I/O operations from the I/O threads via Queue instances, and try to post the request for each input operation as soon as you know you'll eventually need that data. Performance will increase only if there are other tasks your computational threads can perform while an I/O thread is blocked waiting for data. Basically, you get better performance this way if you can manage to overlap computation and waiting for data, by having different threads do the computing and the waiting. See Chapter 14 for detailed coverage of Python threading and a suggested architecture. |
| [ Team LiB ] |


So far in our course, we've had many opportunities to pair with others. They've all definitely been a unique experience. One emotion that arose during a pairing session was relief. It's happened many times for many reasons. Even though I've had a lot of communication with others, I still get the feeling of being on a different page than others. A big part of that feeling is because I've been trying not to compare myself to others as much. And by default, I've convinced myself that I'm constantly playing catch up. But often I've found others are going through the exact same things as myself. It's really been very valuable to know that I share the same emotions as others whether it's the excitement of completing a challenge or the frustration on just getting through a list of instructions. I particularly enjoyed the html/css pairings. I felt that I had a good grasp on the task and my pair and I were able to get through the challenges while also teaching each or new things. I've struggled a bit more in ruby. And my confidence was not there at first. About a week and a half ago, long before reading my feedback, I decided that I need to show more confidence in when pairing. This will be beneficial to both of us. After looking through my feedback, I wasn't surprised to see that a pair had suggested having more confidence in myself. I didn't really need to read the feedback to know how things went in the pairing sesssions. With most of my pairs, we've been able to talk openly about things that did and didn't work. I guess reading the feedback just reafirmed how I imagined things have been going. And really, they've been a confidence booster. I've been competitive all my life and have competed in multiple sports. I've been working on the habit of thinking "If I'm not winning, then I'm loosing". As I pair with more people, I've able to think of us as all being on the same team. And we're all driving towards the same goal of graduating! I really have seen myself growing both technically and culturally.


SweetFreeStuff.com
///////////////////////////////////////////
Free Bandana from Marlboro
Posted: 11 Aug 2013 09:50 AM PDT
http://feedproxy.google.com/&;r/SweetFreeStuff/&;3/lUZlTALBv9w/?utm_source=feedburner&utm_medium=email
Login or register. Check your offers to see if if there are any bandanas
left. They are giving out 2,000 a day at noon until October 31st. If you
dont get one today, you can try again tomorrow. Get it for Free
///////////////////////////////////////////
Free 30 Day Supply of MDR Stress Tabs
Posted: 11 Aug 2013 09:39 AM PDT
http://feedproxy.google.com/&;r/SweetFreeStuff/&;3/9W8eKIOY_Yk/?utm_source=feedburner&utm_medium=email
Get it for Free!
///////////////////////////////////////////
Free Puffs Fresh Faces Sample
Posted: 11 Aug 2013 06:52 AM PDT
http://feedproxy.google.com/&;r/SweetFreeStuff/&;3/Xxlg19SnJqc/?utm_source=feedburner&utm_medium=email
*Free Samples exhausted, but you can still get a coupon. Sign up for a free
sample and $2 off coupon. Get it for Free!
///////////////////////////////////////////
Free Sample of Murad Rapid Age Spot and Pigment Lightening Serum
Posted: 10 Aug 2013 03:20 PM PDT
http://feedproxy.google.com/&;r/SweetFreeStuff/&;3/uwuub7aXoTo/?utm_source=feedburner&utm_medium=email
Get it for Free!
///////////////////////////////////////////
Earn Cash and Prizes for Scanning Purchases - NCP
Posted: 09 Aug 2013 11:00 PM PDT
http://feedproxy.google.com/&;r/SweetFreeStuff/&;3/CneXXGWgv5A/?utm_source=feedburner&utm_medium=email
As a panel member, the National Consumer Panel will provide you with a
hand-held scanner. Every time you or members of your household shop, youll
use the scanner to scan the barcodes on all of your purchases. Then, once a
week, youll send us your purchase information. Its as easy as that! Youll
earn gift []


JavaScript Objects Cheat Sheet
This is a simple cheat sheet about JavaScript objects. It is just my collection of notes I have been collecting on using and working with JS objects.
// literal notation object var james = { job: "programmer", married: false, speak: function( feeling ) { console.log("Hello, I am feeling " + feeling); }; // property detection in objects with hasOwnProperty if ( james.hasOwnProperty("job") ) { console.log(james.job); } else { james.job = "Student"; console.log(james.job); } // constructor notation logic function Person(first, last, job, married) { this.firstname = first; this.lastname = last; var age = 0; // age is private this.job = job; this.married = married; this.speak = function() { console.log("Hello"); }; // this public method return the age this.getAge = function(){ return age; }; // this is a private function var toggleMarried(){ this.married = ! this.married; }; } // create a "gabby" object using the Person constructor var gabby = new Person("student", true); // inheritance with prototype // chain of inheritance and going up the chain to find properties function Animal(name, numLegs) { this.name = name; this.numLegs = numLegs; this.isAlive = true; } function Penguin(name) { this.name = name; this.numLegs = 2; } function Emperor(name) { this.name = name; this.saying = "Waddle waddle"; } // set up the prototype chain Penguin.prototype = new Animal(); Emperor.prototype = new Penguin(); var myEmperor = new Emperor("Jules"); console.log( myEmperor.saying ); // should print "Waddle waddle" console.log( myEmperor.numLegs ); // should print 2 console.log( myEmperor.isAlive ); // should print true //Creating objects, properties and functions var students = ["Joseph", "Susan", "William", "Elizabeth"] var scores = [ [80, 70, 70, 100], [85, 80, 90, 90], [75, 70, 80, 75], [100, 90, 95, 85] ] var average = function( array ) { var total = 0; for (var i = 0; i < array.length; i++){ total += array[i]; } return total / array.length; }; // create a gradebook object var gradebook = {}; // create a property for each of the students and give each corresponding scores for ( var i = 0; i < students.length; i++ ){ gradebook[students[i]] = {}; gradebook[students[i]].testScores = scores[i]; } // add a function to add a score to a student gradebook.addScore = function(student, score){ this[student].testScores.push(score); }; // add a function to get a student's average score gradebook.getAverage = function( student ){ return average(this[student].testScores); };


Last week, the party teleported back to Kilrein, the capital of Kilvas. They found themselves in a dark stone room underground. By a heavy iron door, a sign was hung, telling them to wait for Winston to come get them. The party considered this for a few seconds before Antimony, Lorelei, and Lord Khallus worked together to bash the door down1. Outside, the party found a narrow hallway that held two terrified guards, who explained that they were underneath one of Kilrein's jails. The party argued for a while about whether to leave immediately or to wait for Winston - an argument that quickly blossomed to encompass larger questions like "what should we do about this Book of Creation thing" and "who is this Winston fellow anyway". They also renamed one of their guards Terry, and coerced him into joining the party for good measure.
After observing the party for some time as they argued, a cloaked figure emerged from the shadows of the stairwell leading to the surface. He approached the party and introduced himself as Winston. Despite some initial misgivings, the party allowed him to approach and began questioning him about the Book of Creation, Torvid, and anything else that came to mind.
Winston explained2 that the knowledge of how to the curse on the Book of Creation could be found in the ruins of the Temple of Truth3. Unfortunately, those ruins are located on the coastline of the Moravian Empire, rendering them difficult to access. Winston speculated that, if the party did find out how to remove the curse, it would reveal the Moravian Empire as being evil and cause the world to unite against them.
Removing the curse would likely have other effects as well. According to Winston, ancient maps indicate that the world was once significantly larger than its current size, and the Edge of the World4 was much more distant than it is now. Removing the curse might reveal long-forgotten lands beyond the Edge of the World, which would hopefully provide allies in the fight against the Moravian Empire.
Winston also explained the current political situation in Kilrein. Reletharian, the elven king of Kilvas, was preparing to cede control of the northern half of the island to Torvid's forces in exchange for peace. Meanwhile, the Moravian Empire was apparently at war with the dragons, but no one was sure exactly why.
The party considered this, and decided to split up. Most of the party would travel to Galia5, where they would try to convince Galia's ruling council to send military support to Kilvas. That group would then travel to find the dragons in the Spine of the World6, where they would essentially try to do the same thing. The rest of the party would try to find Jed to help him slow down Torvid's forces as they advanced on Kilvas7. Meanwhile, Winston would recruit a crew in Kilrein that would sail to the Temple of Truth. Once the party was ready, they would all teleport to that ship and search for a way to fix the Book in the Temple of Truth.
After going through this entire process, the party celebrated its conclusion by traveling to a warehouse and beating up some evil pirates.
Show up this week to enjoy elven politics!


This visualisation operated from March to July 2020. It relied on the excellent UK-wide local-level data compiled by Tom White. Tom is, understandably, no longer updating that dataset. He has done an excellent volunteer job over the past five months maintaining this data in a consistent manner regardless of how England, Scotland, Wales and Northern Ireland have moved or changed what they do. This visualisation wouldn't have been practical without Tom's efforts. Ideally someone in central Government would be compiling consistent, local-level, time-series data across the whole of the UK. Meanwhile, we still have a variety of local authority level hexmaps showing other COVID-19-related data.


No search term entered
No stored slots serial number contain: {{searchTerm}}
Serial Number: {{slot.SerialNumber}} |Machine #:{{slot.SlotNumber}} |License #:{{slot.LicenseNumber}}
Location:{{slot.DisplayLocation}} |Zone:{{slot.Zone}} |Floor Address:{{slot.Address}}
Manufacturer: {{slot.DisplayManufacturer}} |Updated By: {{slot.DisplayUpdatedBy }}
{{slot.WorkflowState}}


AES System
What would you like to do?
Password length
6
7
8
9
10
11
12
13
14
15
Generate password
Hide password
Generate key
We're sorry we can't apply that discount
Your user registration was successful.
Select plaintext file
Select key file
Encrypt
Decrypt
Home Page


[ .. ]
can't match globs. Use [[ .. ]]
or grep.
if [ $var == *[^0-9]* ]
then
echo "$var is not numeric"
fi
if [[ $var == *[^0-9]* ]]
then
echo "$var is not numeric"
fi
[ .. ]
aka test
can not match against globs.
In bash/ksh, you can instead use [[ .. ]]
which supports this behavior.
In sh, you can rewrite to use grep
.
if echo $var | grep -q '^[0-9]*$'; then
echo "$var is numeric"
fi
None. If you are not trying to match a glob, quote the argument (e.g. [ $var == '*' ]
to match literal asterisk.


{{#isolate}} {{! css positioning is calculated only once, we don't want to lose it}}
{{#if isLoaded}}
{{! Because the computation of items is itself reactive (not just the cursor)
it needs isolation, but must remain in this template to access the data context }}
{{#isolate}}
{{#each items}}
-
{{itemTemplate ..}}
{{/each}}
{{/isolate}}
{{else}}
loading...
{{/if}}
{{/isolate}}
{{/if}}


This section will include information about the Nyzo sentinel application. For ease of maintenance, Nyzo sentinel is included in the Nyzo verifier repository. All code specific to the sentinel is in the co.nyzo.verifier.sentinel package.


{% extends "_base.html" %} {% block meta_title %}PyCon CZ Team{% endblock %} {% block content %}
PyCon is a community event. There are more than 30 people on our Slack channel and even more volunteers helped us by sending PR on GitHub. If you drew the organization structure of the PyCon CZ team, you — the attendee would be at the top. The incredible amount of volunteers would follow. There's little or no difference between organizers and volunteers, because we all do it in our free time without any claim for wage. Below is a list of our core team members.
We are here for you
Main contact info@pycon.cz


This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page
This is a paragrhap for the web page


This is a simple app, a simple application that converts one currency to another while offline or online.


This rule checks that api scope does not depend on base scope. Api scope is only allowed to depend on the api scope of another component.
package com.devonfw.ide.sonarqube.common.api; import com.devonfw.ide.sonarqube.common.base.Bar; public class MyClass {}


This section of the assistant aims at building a catalog of Attack Modes.
- Manage Systems
- Where the analyst can create a system and describe the Threat Model associated with it.
- Manage System's Attacks
- Tool that help compiling a list of attacks that appears specifically on this system. The list of available Attacks is contrained by the Threat Model
- View SCREAM Analysis Results
- The results of the SCREAM analysis of a system are compiled here. It displays the STC allowed by the Threat Model along with the results of the attacks that are linked to the said system.


Design process : overview
- Introduction to the concept
- Design process : overview
- Beam model : variational approach
- Beam model : equilibrium approach
- New discrete beam element
- Implementation & test case
Formfinding > Gridfinding
Shorter cycles
Design Process
Curvature Analysis
|
|
NURBS Modeling Surface Curvature Evaluation
|
|
|
|
|
Compass Method Spline Curvature Evaluation
[Otto 1971], [Masson 2017]
|
Structural Analysis
|
|
Formfinding Bending Stress Analysis
[Adriaenssens 2001], [Douthe 2007]
|
|
|
|
Structural Analysis Eurocode
[Oasys GSA]
|
Results & Limitations
Results
- Gridfinding > enhanced exploration of the design space
- Curvature analysis > agility
- Formfinding > real-time mechanical insights
Limitations
- Beam model is only 3-DOFs
- No torsion
- No anisotropic cross-section
- No transfert of moment
- No complex connection kinematics
- No concentrated applied loads


Speakers
These speakers represent some of the most exciting companies out there, and they're all doing amazing things with Go. Come learn from the people who are pioneering Go deployments across the globe. With a lineup like this, you can't go wrong!
Rob Pike - Google Inc Opening Day Keynote Thursday, 24 Apr 8:30am (1h)
Rob Pike is a Distinguished Engineer at Google, Inc. He works on distributed systems, data mining, programming languages, and software development tools. Most recently he has been a co-designer and developer of the Go programming language. Before Google, Rob was a member of the Computing Sciences Research Center at Bell Labs, the lab that developed Unix. While there, he worked on computer graphics, user interfaces, languages, concurrent programming, and distributed systems. He was an architect of the Plan 9 and Inferno operating systems and is the co-author with Brian Kernighan of The Unix Programming Environment and The Practice of Programming. Other details of his life appear on line but vary in veracity.
Derek Collison - Founder, CEO at Apcera Building High-Performance Systems in Go - What’s New and Best Practices Thursday, 24 Apr 9:30am (30m)
Derek Collison is the founder and CEO of Apcera, a San Francisco-based company building the modern enterprise IT platform.
Derek began his career at the Johns Hopkins Applied Physics Lab, where he created advanced visualization applications, configured multiple computers to do the work of a supercomputer, and first encountered large-scale distributed systems. He moved to Silicon Valley shortly thereafter and in 1993, joined a startup called Teknekron Software. He would spend 12 years with the company, which became TIBCO Software. At TIBCO, Derek designed and implemented a wide range of messaging products, including Rendezvous and EMS. As TIBCO’s Senior VP and Chief Architect, Derek led technical and strategic product direction and delivery. The company grew rapidly during this period and was ranked as the largest independent integration software developer, with revenues reaching a record high of $387 million.
Derek continued his pioneer engineering work as one of only two Technical Directors at Google. For Gmail, he added pictures from an email’s author. Then, he co-founded the AJAX APIs group and conceived the idea to cross-cache popular AJAX libraries through hosting on a common Google domain for all to use. During this time, Google experienced astounding growth, as revenues increased more than sevenfold to $23 billion.
Next, Derek was approached with the opportunity to invent something new at virtualization giant VMware. He came up with the idea of a private Platform as a Service and was CTO of the company’s Cloud Services division, which he co-founded. A key figure in the cloud computing sphere, Derek left his mark at VMware with a career-defining invention. He designed and architected Cloud Foundry, the first and industry-leading Open PaaS that also established an ecosystem for other PaaS systems today.
After over two decades in enterprise computing with first-hand experience of its limitations, Derek envisioned building a solution from the ground up that would solve today’s IT challenges as well as grow with the future. In 2012, he founded Apcera with the vision of creating a platform that drives enterprise IT to innovate faster. Today, he leads the company toward turning that vision into reality. With numerous software patents and frequent speaking engagements, Derek is a recognized leader in distributed systems design and architecture, and emerging cloud platforms. He lives in San Francisco.
Petar Maymounkov - gocircuit.org and Data Tactics Corp. The Go Circuit: Towards Elastic Computation with No Failures Thursday, 24 Apr 10:00am (30m)
I obtained my B.A. in Mathematics and Computer Science from Harvard University in 2001, where my adviser was Prof. Michael Mitzenmacher. My interest in Coding Theory and Probabilistic Algorithm Design—which later reached fruition in well-received works on rateless and network coding—was born in Michael’s classes.
From 2001 to 2003, I attended the Ph.D. program in Computer Science at the Courant Institute of Mathematical Sciences at NYU, which resulted in my M.Sc. in Computer Science. My tastes and interests, in systems and theory, were very influenced by my adviser Prof. David Mazières—now a Stanford University professor—and Prof. Joel Spencer—a true gentleman of Mathematics. With David I completed my currently most impactful work on Kademlia: a distributed algorithm that enables billions of peers to store and discover information collaboratively.
In 2012, I obtained my Ph.D. from MIT, Computer Science and Artificial Intelligence Lab, happy to have been advised by Prof. Jonathan Kelner and supported by Prof. Frans Kaashoek. At MIT I concentrated on Spectral Graph Theory and its applications to distributed combinatorial and numerical algorithms. My work with Jon on electric routing is the foundation for a new generation of robust, resilient, secure and anonymous computation systems, built on top of socially-engineered often-faulty communication topologies.
Following, during 2012, I worked at Tumblr, Inc. where I developed a new paradigm for efficient development and sustenance of data-processing distributed applications, The Go Circuit Project. I am interested in all aspects of distributed applications: the languages and tools we use to build them, the higher-level software metaphores we build to hide away the complex semantics of subsystem failures in distributed systems, design and analysis of numerical algorithms for pivotal problems (no pun) like solving linear systems and sketching massive structured data, even more general tools for the more challenging peer-to-peer setting.
I am an avid Ashtangi and rock climber.
William Kennedy - Managing Partner at Ardan Studios Building an Analytics Engine using MongoDB and Go Thursday, 24 Apr 10:45am (30m)
William Kennedy is a managing partner at Ardan Studios in Miami, FL and is the author of GoingGo.Net. Ardan Studios is a Mobile and Web App Development company. Bill has been a software developer for over 20 years developing back end systems for the call center, gaming and financial industries. Bill looked for a new language that would allow him to develop back end systems in Linux and found Go. He has never looked back. He has been married for 18 years. He and his wife enjoy their five kids, four cats, one dog and all the wild animals who have found a home on the Kennedy compound.
Josh Bleecher Snyder -
Software Engineer at PayPal / card.io
Embedded Go and Bluetooth Low Energy Hardware
Thursday, 24 Apr 11:15am (30m)
Josh is the technical co-founder of card.io (acquired by PayPal in 2012).
Kelsey Hightower - Puppet Labs Go for Sysadmins Thursday, 24 Apr 11:45am (30m)
Kelsey Hightower is a System Admin with over 10 years of experience in making IT problems disappear using the power of unix, programming, and empathy.
Rob Miller - Senior Engineer at Mozilla Data Snarfing with Go: A Heka Good Time Thursday, 24 Apr 1:15pm (30m)
Rob Miller is a long time Pythonista who has recently taken up Go for fun and profit. Rob works as a member of Mozilla's Services team, tackling the problem of connecting all of the data generated by their servers and services with the eyeballs that want to actually see that data. When not juggling bits, he can often be found juggling children and chainsaws.
David Symonds - Software Engineer at Google Gophers on a Plane: The Story of Go on App Engine Thursday, 24 Apr 1:45pm (30m)
David is an engineer on the Go team at Google. He leads the development of the Go runtime for App Engine, and works on various internal Google technologies. He's been writing Go since early 2009.
Ben Johnson - Founder at Skyland Labs, Inc. Writing a High Performance Database in Go Thursday, 24 Apr 2:15pm (30m)
I'm an open source software developer focused on behavioral analytics, distributed systems, and data visualization. I've started several popular, open source Go projects including SkyDB, go-raft, and megajson. I'm also a core contributor to CoreOS' etcd project.
Kelsey Falter - Founder, CEO at Poptip From Node.js to Go Thursday, 24 Apr 3:15pm (30m)
Kelsey is the founder of Poptip, which analyzes and synthesizes social conversation in real-time for top media broadcasters, news organizations, and Fortune 500 brands. As CEO of Poptip, Kelsey was fundamental in making the decision to transition Poptip from a Node.js backend to a Go backend.
Kelsey was part of a Top 10 Node Knockout qualifying team in 2012, and in 2014 she was featured on Forbes 30 Under 30 in Tech. She was named one of Business Insider’s 25 and Under in NY Tech 2012 list and received the L’Oreal Women in Digital Award in 2013. Kelsey has spoken at Bloomberg Next Big Thing Summit, Northside Festival, SXSW, and is a NYC Venture Fellow.
Matt Reiferson -
Control Tower Operator at Torando Labs
Spray Some NSQ On It
Thursday, 24 Apr 3:45pm (30m)
Matt Reiferson is an American software engineer, lunch instructor, and fan of TV's Bob Ross. He is best known as the creator and host of The Joy of Coding in DOS, a television program that ran for twelve years on PBS stations in the United States.
Mike Gehard - Software Engineer at Pivotal Labs Taking Back the Command Line with Go Thursday, 24 Apr 4:15pm (30m)
Mike Gehard works for Pivotal Labs in Boulder, Colorado. While he still loves Ruby for certain jobs, Go has rekindled his love of statically typed, compiled languages for those jobs where Ruby doesn't fit.
Brad Fitzpatrick - Gopher at Google Camlistore & The Standard Library Thursday, 24 Apr 4:45pm (30m)
Hacker. see bradfitz.com
Russ Cox - Engineer at Google Go from C to Go Friday, 25 Apr 8:30am (30m)
Russ Cox has worked on the Go programming language at Google since 2008. Before working on Go he developed Google's Code Search, which let programmers grep through the world's public source code; he wrote the search engine for the Online Encyclopedia of Integer Sequences; and he hacked at Bell Labs on the Plan 9 operating system. He earned his AB and SM from Harvard in 2001 and his PhD from MIT in 2008.
Gustavo Niemeyer - Thinker at Canonical Painless Data Storage with MongoDB and Go Friday, 25 Apr 9:00am (30m)
Gustavo works for Canonical, the company that supports Ubuntu, and has been contributing to the Go language and community for almost as long as the language has been publicly known. He's the author of a number of well known packages such as the MongoDB driver, goyaml, gocheck, pipe, and many others, and is also the technical lead that designed and brought the juju orchestration framework to life within Canonical.
Steve Francia -
Software Engineering Lead at MongoDB
Painless Data Storage with MongoDB and Go
Friday, 25 Apr 9:00am (30m)
Steve Francia is the creator of hugo, cobra, nitro & spf13-vim. An author of multiple O'Reilly books, Steve also blogs at spf13.com and gives many talks and workshops around the world. He is the Chief Developer Advocate at MongoDB responsible for the developer experience ofMongoDB and leads the software engineering team responsible for drivers and integrations with all languages, libraries and frameworks. He lovesopen source and is thrilled to be able to work on it full time. When not coding he enjoys skateboarding and having fun outdoors with his wife and four children.
Peter Bourgon - Engineer at SoundCloud Best Practices for Production Environments Friday, 25 Apr 9:30am (30m)
Peter Bourgon is a distributed systems engineer with a background in information retrieval. Peter has been active in the Go community since its release, and has worked professionally with Go since 2011. Peter cares deeply about software elegance, maintainability, and best practices.
John Graham-Cumming -
Programmer at CloudFlare, Inc.
A Channel Compendium
Friday, 25 Apr 10:30am (30m)
John Graham-Cumming is a computer programmer and author. He studied mathematics and computation at Oxford and stayed for a doctorate in computer security. As a programmer he has worked in Silicon Valley and New York, the UK, Germany and France and currently works at CloudFlare. His open source POPFile program won a Jolt Productivity Award in 2004.
He is the author of a travel book for scientists published in 2009 called The Geek Atlas and has written articles for The Times, The Guardian, The Sunday Times, The San Francisco Chronicle, New Scientist and other publications.
He can be found on the web at jgc.org and on Twitter as @jgrahamc.
If you've heard of him at all, it's likely because in 2009 he successfully petitioned the British Government to apologize for the mistreatment of British mathematician Alan Turing.
He is a licensed radio amateur.
Victor Vieux - Software Engineer at Docker, Inc Making Docker GO: Why One of the Fastest Growing Open Source Projects Friday, 25 Apr 11:00am (30m)
Victor Vieux works as a software engineer at Docker, Inc. He is one of the four guys that form the internal Docker Core team. Originally from Paris, France, where he was famous for his work on robots (programming them in C/C++), Victor joined the company and project at the very beginning. Since then he's been helping both on programming the Docker core and helping the Docker community, 24/7, with passion and enthusiasm.
Stephen McQuay - Senior Software Engineer Writing and Debugging a Web-Based Multi-Player Game Friday, 25 Apr 11:30am (30m)
Stephen is a classically trained Mechanical Engineer who now enjoys writing and testing software. Having recently moved to the Bay Area, he previously co-presided over the Utah Python User group for a number of years and participated actively in the Utah Open Source Conference. He has presented on topics as varied as Virtualenvs and why to use them, Parallel processing in Python, Blender Modeling Basics, Introduction to c++11, Setting up an at-home HPC Cluster, among others.
While still a fairly junior software engineer, he brings a passion for problem solving and loves presenting on the stuff about which he is learning.
When not typing on a keyboard he enjoys herding cats, or as most call it helping raise three kids with his awesome wife Vanessa.
Fraser Graham -
Former Veteran Game Programmer
Writing and Debugging a Web-Based Multi-Player Game
Friday, 25 Apr 11:30am (30m)
I worked in video game development for over ten years for Microsoft, Take Two and Disney. I covered areas ranging from low level engine development and 3D rendering to web based infrastructure tools, online services, analytics and art workflows. I got tired of video games in 2012 and moved to the Bay Area where I work on things that are entirely different from video games and much more enjoyable. My recent experience is mostly in Objective-C, Python, Django, Go, Javascript and other web technologies but my background is mostly C/C++.
Ron Evans - Ringleader at The Hybrid Group Gobot: Go Powered Robotics and Physical Computing Friday, 25 Apr 1:00pm (30m)
Ron Evans is a software developer who has been active in the free and open source community for over 20 years. As ringleader of The Hybrid Group, he helps clients solve some of their most difficult technical and business problems. Ron has presented at conferences such as GoGaRuCo, RubyConf, FutureRuby, Ignite, L.A. Ruby Conference, Conferencia Rails, and MagmaConf. Ron is an active contributor to many open source projects and created the award-winning KidsRuby, free software to help teach Ruby programming to kids.
Adrian Zankich -
Serious Programming Guy at The Hybrid Group
Gobot: Go Powered Robotics and Physical Computing
Friday, 25 Apr 1:00pm (30m)
Adrian is the "Serious Programming Guy" at The Hybrid Group, and the primary contributor to Gobot. Adrian is quickly becoming known to the open source community from speaking at RubyConf, RubyKaigi, MagmaConf, LARubyConf, and other tech conferences. A Los Angeles native, he has worked on Telematics-based web applications for a number of companies and has explored a wide range of technologies, from Go to Ruby to JavaScript, cloud computing, and firmware development, and integrated many different system in his client work, as well as his many contributions to KidsRuby.
Blake Mizerany - Funemployed Little Known Tricks Used in Go's stdlib Friday, 25 Apr 1:30pm (30m)
Blake has been working professionally in Go since 2009. He co-created distributed and consistent key/value store Doozer, created the pure Go postgres driver for Go's database/sql, created the blazing fast logfmt package, and tracks your datas quantiles/topk/histograms with his perks/quantile package.
Baron Schwartz - CEO at VividCortex Building Database Applications with database/sql Friday, 25 Apr 2:00pm (30m)
Baron is the co-founder of VividCortex. He's well-known in the MySQL community for his open-source software and for authoring High Performance MySQL.
Alan Shreve - Programming Nomad Build Your Developer Tools in Go Friday, 25 Apr 3:00pm (30m)
Alan is the creator of the popular developer tool ngrok. He built distributed systems, telecom gateways and continuous deployment systems at Twilio, web applications at Fog Creek, hacked operating system kernels at Microsoft, and writes games and developer tools for personal projects. He slings everything from Javascript to C, but Go is his weapon of choice.
Richard Crowley Building Web Services In Go Friday, 25 Apr 3:30pm (30m)
Richard is something of a polyglot, working frequently in C, Go, Java, JavaScript, Puppet, Python, Ruby, and shell. He's the creator of the Blueprint configuration management tool, a contributor to Go and Puppet, and has worked at Betable, OpenDNS and Flickr. He's passionate about engineering tools and practice and thinks vi is a better religion than emacs.
Andrew Gerrand - Engineer at Google Closing Day Keynote Friday, 25 Apr 4:00pm (50m)
Andrew Gerrand works on the Go Programming Language at Google Sydney. He has written dozens of articles about Go, and given many talks and workshops at conferences around the world. He is the co-author of A Tour of Go, and is the fourth most prolific contributor to the Go project. He is passionate about software quality, and believes Go is a unique tool for building reliable software at scale. Before Go and Google, Andrew wrote software for Internet companies.
Connect with us
Join our mailing list


Power Outages?
By an edhat reader
Has anyone lost power outside the PSPS area? I'm downtown and the lights have been flickering off and on for the past few minutes. SoCal Edison wouldn't cut our power since we're so far away from the fire right?
By an edhat reader
Has anyone lost power outside the PSPS area? I'm downtown and the lights have been flickering off and on for the past few minutes. SoCal Edison wouldn't cut our power since we're so far away from the fire right?


Graphical User Interface¶
The waveserv program directly indexes and reads the (SEG-Y) files in the directory working directory on the server, handling endian and floating point conversion, and provides a directory listing through the web-browser interface. The web-based GUI is rendered by the waveserv executable, which is started using a Command Line Interface.
With the waveserv server running, navigate to http://localhost:1503/index to show the directory listing:
Each type of file is grouped under a descriptive heading, and the entries under each heading are sorted. Several pieces of information are available for each entry, including the filename, size, and modification time. Additionally, for files that correspond to a particular frequency or iteration, this information is extracted from the filename. Each of these headings can be used as a sort key; simply click the corresponding check box (beside the column heading) to change the sort key. The current sort key is indicated by a box that is coloured differently from the others.
New in version 1.1: An indicator shows the freshness of each file graphically.
Each entry has two buttons, labelled Show and Get. Clicking the Get button simply downloads the original file. The Show button beside an entry displays a graphical representation of the file. This takes you to http://localhost:1503/show/filename for a file filename, which is a web address that calls a plotting method, which generates a PNG image.


Ahmad Marzuki
Call me Zuki. I’m a Passionate Full Stack Developer and this is my personal website. I built it myself from scratch. Feel free to wander around this web to know more about me.
Call me Zuki. I’m a Passionate Full Stack Developer and this is my personal website. I built it myself from scratch. Feel free to wander around this web to know more about me.


To Order
To order this CD or download, please click here.
Discounts for large orders available. Please email<EMAIL_ADDRESS>for more information.
CD: Produced by Jill Jacobsen; Music written and produced by Inge Berge © I. Berge/Zerosongs (ASCAP) Used by permission, all rights reserved; Written and narrated by Jill Jacobsen; Movement sequence: Ivana Ustariz; Design and Photography; Melanie Lloyd; Web Site Design: Karen Chemel; © Jill Jacobsen 2012
We hope you love Imagination Vacation and want all your friends and family to have it. We do, too! But please don’t copy and give away this work. Share this link instead. Thank you.


What type of job are you looking for?
Pay per Hour:
Experience:
Work Atmosphere:
Casual Professional Busy Flexible


‘Tanhaji: The Unsung Warrior’ trailer pits mighty battle between Ajay Devgn and Saif Ali Khan
The movie will see the husband-wife duo of Ajay and Kajol share screen space for the first time in more than a decade
by The Hindu Net DeskThe trailer of Ajay Devgn’s 100th film in the Hindi industry, Tanhaji: The Unsung Warrior, has been released, and promises to be a treat for fans of war epics. The movie will release in 3D as well, with the makers pulling no stops to ensure it is a spectacular viewing experience.
The movie will see the husband-wife duo of Ajay and Kajol share screen space for the first time in more than a decade, since U Me Aur Hum in 2008. The movie also stars Saif Ali Khan in a prominent role, as well as others like Jagapathi Babu, Pankaj Tripathi and Sharad Kelkar.
Directed by Om Raut and produced by Ajay Devgn himself, the film depicts the story of Maratha warrior Tanhaji Malusare (Ajay) who fights the Sinhagad Battle against Udaybhan Singh Rathod (Saif). Kajol is seen in the role of Tanhaji's wife Savitribai Malusare, who supports her husband in a battle for the ages.
Ajay shared the trailer of the film posting, “4th Feb 1670: The surgical strike that shook the Mughal Empire! Witness history like never before. Presenting the official #TanhajiTrailer.”
The movie is set release on January 10, 2020.