Backing Up Your Community Manager Data
- Go to the Google Sheets page
- Click on File -> Download As
- Choose how you want to download to local machine. (Excel is easiest.)
Adding New Admins
- Got to the Google Sheets page: admins tab
- Add an email address that is linked to a google account.


Geomethod Vectorizer setup program unpacks the necessary files and shortcuts on your computer. This program is distributed for free and you are licensed to use this software without any charge.
GMVectorizer.exe - Geomethod Vectorizer program
GMVectorizer.chm - html help file for the program
To uninstall the program click 'Add/Remove Programs' item at Control Panel, then choose 'Geomethod Vectorizer' item and click 'Remove' button.


There’s a bug with how GCC is installed on the supercomputer, which prevents installation of ANTs. Luckily there’s a solution.
Make sure you start with a completely fresh install. Remove the ANTs
and antsbin
directories:
Follow the directions provided by ANTs:
In CMAKE, type “c” to load the configuration information and then type “t” to toggle to advanced mode. You want to edit the option, “CMAKE_EXE_LINKER_FLAGS” which by default is blank, but needs to be -fuse-ld=bfd
instead. Press “ENTER” to edit the option.
Type “c” and then “g” and then exit back to the terminal by typing “q”.
Compile your code:
and wait awhile.
Once ANTs is installed, remember to copy the scripts to your ANTs bin directory and set your environmental variables:


High Quality
Well Tested high performant utility first angular directives and components without the hassle of dealing with CSS.
Utility First
Includes utility directives that help you build any design directly in your markup.
Frictionless
Non interfering, can coexist with any other css or ui libraries.
Guides
Get Started
Know how to add and use ngw in your angular app.
Widgets
Know about all the components NGW is offering.
Theme
Know how to customize and theme NGW components.


The Jinja2 sandbox can be used to evaluate untrusted code. Access to unsafe attributes and methods is prohibited.
Assuming env is a SandboxedEnvironment in the default configuration the following piece of code shows how it works:
>>> env.from_string("{{ func.func_code }}").render(func=lambda:None)
u''
>>> env.from_string("{{ func.func_code.do_something }}").render(func=lambda:None)
Traceback (most recent call last):
...
SecurityError: access to attribute 'func_code' of 'function' object is unsafe.
The sandboxed environment. It works like the regular environment but tells the compiler to generate sandboxed code. Additionally subclasses of this environment may override the methods that tell the runtime what attributes or functions are safe to access.
If the template tries to access insecure code a SecurityError is raised. However also other exceptions may occour during the rendering so the caller has to ensure that all exceptions are catched.
For intercepted binary operator calls (intercepted_binops()) this function is executed instead of the builtin operator. This can be used to fine tune the behavior of certain operators.
New in version 2.6.
For intercepted unary operator calls (intercepted_unops()) this function is executed instead of the builtin operator. This can be used to fine tune the behavior of certain operators.
New in version 2.6.
default callback table for the binary operators. A copy of this is available on each instance of a sandboxed environment as binop_table
default callback table for the unary operators. A copy of this is available on each instance of a sandboxed environment as unop_table
a set of binary operators that should be intercepted. Each operator that is added to this set (empty by default) is delegated to the call_binop() method that will perform the operator. The default operator callback is specified by binop_table.
The following binary operators are interceptable: //, %, +, *, -, /, and **
The default operation form the operator table corresponds to the builtin function. Intercepted calls are always slower than the native operator call, so make sure only to intercept the ones you are interested in.
New in version 2.6.
a set of unary operators that should be intercepted. Each operator that is added to this set (empty by default) is delegated to the call_unop() method that will perform the operator. The default operator callback is specified by unop_table.
The following unary operators are interceptable: +, -
The default operation form the operator table corresponds to the builtin function. Intercepted calls are always slower than the native operator call, so make sure only to intercept the ones you are interested in.
New in version 2.6.
The sandboxed environment will call this method to check if the attribute of an object is safe to access. Per default all attributes starting with an underscore are considered private as well as the special attributes of internal python objects as returned by the is_internal_attribute() function.
Works exactly like the regular SandboxedEnvironment but does not permit modifications on the builtin mutable objects list, set, and dict by using the modifies_known_mutable() function.
Raised if a template tries to do something insecure if the sandbox is enabled.
Marks a function or method as unsafe.
@unsafe
def delete(self):
pass
Test if the attribute given is an internal python attribute. For example this function returns True for the func_code attribute of python objects. This is useful if the environment method is_safe_attribute() is overridden.
>>> from jinja2.sandbox import is_internal_attribute
>>> is_internal_attribute(lambda: None, "func_code")
True
>>> is_internal_attribute((lambda x:x).func_code, 'co_code')
True
>>> is_internal_attribute(str, "upper")
False
This function checks if an attribute on a builtin mutable object (list, dict, set or deque) would modify it if called. It also supports the “user”-versions of the objects (sets.Set, UserDict.* etc.) and with Python 2.6 onwards the abstract base classes MutableSet, MutableMapping, and MutableSequence.
>>> modifies_known_mutable({}, "clear")
True
>>> modifies_known_mutable({}, "keys")
False
>>> modifies_known_mutable([], "append")
True
>>> modifies_known_mutable([], "index")
False
If called with an unsupported object (such as unicode) False is returned.
>>> modifies_known_mutable("foo", "upper")
False
Note
The Jinja2 sandbox alone is no solution for perfect security. Especially for web applications you have to keep in mind that users may create templates with arbitrary HTML in so it’s crucial to ensure that (if you are running multiple users on the same server) they can’t harm each other via JavaScript insertions and much more.
Also the sandbox is only as good as the configuration. We strongly recommend only passing non-shared resources to the template and use some sort of whitelisting for attributes.
Also keep in mind that templates may raise runtime or compile time errors, so make sure to catch them.
New in version 2.6.
For maximum performace Jinja2 will let operators call directly the type specific callback methods. This means that it’s not possible to have this intercepted by overriding Environment.call(). Furthermore a conversion from operator to special method is not always directly possible due to how operators work. For instance for divisions more than one special method exist.
With Jinja 2.6 there is now support for explicit operator intercepting. This can be used to customize specific operators as necessary. In order to intercept an operator one has to override the SandboxedEnvironment.intercepted_binops attribute. Once the operator that needs to be intercepted is added to that set Jinja2 will generate bytecode that calls the SandboxedEnvironment.call_binop() function. For unary operators the unary attributes and methods have to be used instead.
The default implementation of SandboxedEnvironment.call_binop will use the SandboxedEnvironment.binop_table to translate operator symbols into callbacks performing the default operator behavior.
This example shows how the power (**) operator can be disabled in Jinja2:
from jinja2.sandbox import SandboxedEnvironment
class MyEnvironment(SandboxedEnvironment):
intercepted_binops = frozenset(['**'])
def call_binop(self, context, operator, left, right):
if operator == '**':
return self.undefined('the power operator is unavailable')
return SandboxedEnvironment.call_binop(self, context,
operator, left, right)
Make sure to always call into the super method, even if you are not intercepting the call. Jinja2 might internally call the method to evaluate expressions.


Click Here to go to my YouTube channel.Yoy can also Read the following
to here more about us:
Origami
We will teach you anything you want about origami. Just email us and we will reply back to you as soon as possible. Click Here to go to my YouTube channel.
Rubik's Cubes and Cubing
We teach videos on 3x3x3, 2x2x2, the pyraminx, and more. If you want more videos on other types of rubik's cubes, email us and we will make another video on that too.
Mazes and Drawling
We have done a couple videos on mazes and Drawling before, so if you want to see more of that, than make sure to let us know.
Mini Jeep and other things
We have done videos on our mini jeep, and some videos on other things, too. If you want to see more videos on our mini jeep and other things, email us and make sure to tell us if you want another mini jeep video or if you have another video idea for us.
Contact Informarion
If you want to get a hold of us, either comment on one of our videos, comment on our discussion tab, or email us at<EMAIL_ADDRESS>and we will get back to you as soon as possible. Click Here to go to my YouTube channel.


This takes a data.frame of arguments to use for your actual run, often generated by something like expand.grid
so that each row represents a unique combination of conditions. It expects the rscript
to be an R file that takes unnamed input arguments, with the first argument being the job number.
fly(conditions, rscript, input_files = NULL, sleep_time = 1, log = "log.$(Process)", output = "out.$(Process)", error = "error.$(Process)", universe = "vanilla", requirements = NULL, other = NULL, submit_file_name = "Rjob.submit", executable_file_name = "run.sh")
| conditions | Grid of conditions to use for run |
|---|---|
| rscript | The R file to run |
| input_files | Any other files needed to run |
| sleep_time | How long between calls to condor_submit |
| log | Log file |
| output | Output file (in addition to ones the script itself creates) |
| error | Error file |
| universe | HTCondor universe to use |
| requirements | Requirements to pass as a requirements call |
| other | Other lines to add to the submit file (such as rank) |
| submit_file_name | Name of the final submit file |
| executable_file_name | Executable file name to make |
packages in the High Performance Task View for R.
# NOT RUN { # Let us imagine we want to do a grid search for the maximum likelihood estimates for the mean and sd for a normal distribution for a set of points. # First you have the points. Let us make them into a file called my_data.rda data_points <- rnorm(1000, mean=3.1, sd=.42) save(data_points, file="my_data.rda") # The following code you would put in a file, let's call it batch.R. This will get the likelihood for a normal distribution for a set of points. args <- commandArgs(TRUE) rep_number <- args[1] set.seed(as.integer(runif(1, 1, 1000) + as.numeric(rep_number))) #to make sure we don't have jobs use the same exact seed if they fire at the same time x_mean <- as.numeric(args[2]) x_sd <- as.numeric(args[3]) load("my_data.rda") # which loads the data. We could instead do read.csv, etc. lnl <- dnorm(data_points, mean=x_mean, sd=x_sd, log=TRUE) save(rep_number, x_mean, x_sd, lnl, file=paste0("Results_Rep",rep_number,"_Mean_",signif(x_mean,2), "_SD_", signif(x_sd, 2), ".rda")) # Then let's try making a set of points to try mean_attempts <- seq(from=-5, to=5, by=1) sd_attempts <- seq(from=0, to=1, by=0.1) conditions <- expand.grid(rep=sequence(3), means=mean_attempts, sds=sd_attempts) Note that we have rep in expand.grid so that each combination is done three times. # Now we can use this function send off the jobs to condor fly(conditions, rscript="batch.R", input_files="my_data.rda") # }


This project was developed using HTML, JavaScript, CSS, and LESS with several parametric mixins and nested styles, different media queries for phone, tablet, and desktop, responsive units for font sizing, and media queries escaped. It has three different animations, coming in from left, right, and bottom. It also has a fourth animation for the checkmarks using SVG.


Construction of Software
A journey through the bits
Familiar faces
What is programming?
buy milk, if there're eggs, get a dozen
talking to computers
but how?
The "natural" language of computers
Our everyday Mac
First ever personal computer
The revolution in how we talk to computers
Punchcard of the 70s
Modern-day source code
Translators
3 types of high-level translators:
- Interpreters
- Compilers
- Hybrid
intepreters
Running the whole source code
Passing every single line of code to the interpreter
Compliers
Go compiler in action
package main
func main() {
println("Hello")
println("Is it me?")
println("You looking for")
}
Go compiler in action
Hybrid
Hybrid in action


--- layout: post title: AutoHotkey Where Have You Been All My Life? date: 2014-02-11 23:44:14.000000000 -05:00 type: post published: true status: publish categories: - Productivity tags: [] meta: dsq_thread_id: '2254318476' _jetpack_related_posts_cache: a:1:{s:32:"8f6677c9d6b0f903e98ad32ec61f8deb";a:2:{s:7:"expires";i:1457770523;s:7:"payload";a:3:{i:0;a:1:{s:2:"id";i:1111;}i:1;a:1:{s:2:"id";i:2135;}i:2;a:1:{s:2:"id";i:2058;}}}} author: login: adminian email<EMAIL_ADDRESS>display_name: adminian first_name: '' last_name: '' ---
Maybe I'm just late to the party, but this tool is just awesome! Install it! Run it, and say yes to let it create the default script. AutoHotKey has it’s own “language” and I use that term loosely. Here are a couple of helpful thing to note that should get you started. The semicolon is a comment:
; Basic modifier symbols:
; # Windows key
; ! Alt key
; ^ Control key
; + Shift key
^!+b::Run www.bing.com
This above command will launch the default browser and navigate to Bing when you press: ctrl + alt + shift + b. I don’t think that some of these long hotkeys seem that useful and frankly I will not remember them. There are however times, when, say I’m having to modify text by pressing down, over, over, over, backspace, backspace rinse and repeat. You know what I’m talking about… This is where AutoHotkey comes to the rescue. To do just that you would:
^#!f::
Down
Left
Left
Left
Backspace
Backspace
Return
You can even loop and other constructs… just awesome! Go forth and do.


Functions
The following functions are available globally.
-
Compare two HTTP methods
Declaration
Swift
public func == (lhs: HTTPMethod, rhs: HTTPMethod) -> Bool
-
Convenience function to begin a mustache template request
Routing.Routes["/"] = { request, response in mustacheRequest(request: request, response: response, handler: UploadHandler(), path: webRoot + "/index.mustache") }
Declaration
Swift
public func mustacheRequest(request req: WebRequest, response: WebResponse, handler: MustachePageHandler, templatePath: String)
-
Returns an empty all zeros uuid_t
Declaration
Swift
public func empty_uuid() -> uuid_t
-
Generate and return a random uuid_t
Declaration
Swift
public func random_uuid() -> uuid_t
-
Returns the current time according to ICU ICU dates are the number of milliseconds since the reference date of Thu, 01-Jan-1970 00:00:00 GMT
Declaration
Swift
public func getNow() -> Double
-
Converts the milliseconds based ICU date to seconds since the epoch
Declaration
Swift
public func icuDateToSeconds(_ icuDate: Double) -> Int
-
Converts the seconds since the epoch into the milliseconds based ICU date
Declaration
Swift
public func secondsToICUDate(_ seconds: Int) -> Double
-
Format a date value according to the indicated format string and return a date string. - parameter date: The date value - parameter format: The format by which the date will be formatted - parameter timezone: The optional timezone in which the date is expected to be based. Default is the local timezone. - parameter locale: The optional locale which will be used when parsing the date. Default is the current global locale. - returns: The resulting date string - throws:
PerfectError.ICUError
- Seealso Date Time Format SyntaxDeclaration
Swift
public func formatDate(_ date: Double, format: String, timezone inTimezone: String? = nil, locale inLocale: String? = nil) throws -> String
Parameters
date
The date value
format
The format by which the date will be formatted
timezone
The optional timezone in which the date is expected to be based. Default is the local timezone.
locale
The optional locale which will be used when parsing the date. Default is the current global locale.
Return Value
The resulting date string


1. An optical illusion
2. An unrealistic hope or wish
Saturday 11th February, 8pm-3am
Applications have now closed! If you need to get in touch with the committee for audition or performing information, please email<EMAIL_ADDRESS>Worker applications have closed. If you have any questions about working at Churchill Spring Ball, please contact<EMAIL_ADDRESS>Grime legend Big Narstie will headline Churchill Spring Ball 2017. Prep yourself for When The Bassline Drops, because we're gonna have a mad one.
Be sure to like our Facebook Page and follow our Instagram @springball2017 to stay up to date with all important announcements.
{{ type.description }}
£ {{ type.price | number:0 }} .{{ type.price | pennies }}


checkr Naming Schemes
Joe Thorley
2019-04-24
The checkr
packages provides a series of functions that can be used to check the values and classes of common R objects. Before attempting to use the functions it is worth understanding the checkr function naming schemes.
Primary Objects
As discussed in the Data Structures chapter in Advanced R by Hadley Wickham, the five main object types are defined by their dimensionality (1d, 2d and nd) and whether they are homogenous or heterogenous. Currently the check_vector()
, check_list()
and check_data()
functions allow the user to check the type and values of the three main type of (atomic) vectors, lists and data frames. The check_matrix()
and check_array()
equivalents have yet to be implemented. The functions are named according to the type of the object they check.
It is worth noting that a while a vector, matrix or array will definitely pass the check_homogenous()
function, a list or data frame may pass it if all its elements have identical classes.
Scalars
In addition to (atomic) vectors the checkr package also identifies scalars which in R are (atomic) vectors with one element. They can be tested using the check_scalar()
function.
Often function arguments are scalars of a particular type. For example the default mean()
function has an argument na.rm
which is a logical indicating whether NA
values should be stripped. The checkr package provides the following functions to test whether objects are non-missing scalars of particular types:
check_lgl()
: a non-missing logical scalar i.e. TRUE
or FALSE
check_int()
: an non-missing integer i.e. 1L
check_dbl()
: an non-missing double scalar i.e. 1.1
check_prop()
: a non-missing double scalar between zero and one, i.e. 0.35
check_chr()
: a non-missing character scalar, i.e. "text"
check_date()
: a non-missing Date scalar i.e. as.Date("2001-02-03")
check_dttm()
: a non-missing POSIXct scalar
It is also worth noting that almost all the scalar functions include an argument coerce
which if set to TRUE
tests whether the object satisfies the condition after coercing to the required type. If the test passes then the function returns the coerced object.
Other Objects
Functions to test whether an object is another type of object include check_null()
, check_environment()
and check_function()
.
In addition the check_classes()
and check_inherits()
functions can be used to check the classes or inheritance of an object.
Function Functions
Many other checking functions are named according to the main base function that they use. Thus the check_nrow()
function uses the nrow()
function to check the number of rows while the check_nlevels()
function uses the nlevels()
function. It is important to realize that these functions do not check the type of an object but simply whether the return value of the base function(s) is consistent with the user defined conditions.
Functions which fall in this category include check_class()
, check_colnames()
, check_length()
, check_levels()
, check_names()
, check_nchar()
, check_ncol()
, check_nlevels()
, check_nrow()
and check_sorted()
.
Data Functions
The check_join()
function tests whether the columns in one data frame form a many-to-one join with corresponding columns in a second data frame. The check_key()
function tests whether specific columns are unique. They are useful for testing whether a set of data frames can be archived in an relational database.
Miscellaneous Functions
The remaining functions which are not captured by the above naming schemes include checkor()
, check_named()
, check_pattern()
, check_regex()
, check_sorted()
, check_tzone()
, check_unique()
, check_unnamed()
and check_unused()
.


Primary Public Key: {{wallet.primary_key}}
Secondary Public Key: {{wallet.secondary_key}}
TrustedCoin Public Key: {{wallet.trustedcoin_pubkey}}
Address Script: {{wallet.script}}
TrustedCoin Cosigning Fee: {{wallet.trustedcoin_fee}} Satoshis
Save Mnemonic
For convenience, you can save a local copy of your mnemonic encrypted with a simpler password.
Remove local copy of mnemonic


[gecode-users] Redirect the output of a MinimizeScript
Guido Tack
tack at gecode.org
Fri Sep 30 18:55:43 CEST 2011
On 30 Sep 2011, at 18:12, Nacho Castiñeiras wrote:
> Hi,
> is it possible to redirect the output of the MinimizeScript "print" function to
> an external file?
>
> I have looked to the examples of the Gecode distribution and the print function
> is always implicitly called by the MinimizeScript::run method.
It's possible, but you will have to run the search yourself instead of through the MinimizeScript::run method.
See the "send most money" example from Sect. 3.2 of MPG:
http://www.gecode.org/doc-latest/MPG/send-most-money-with-cost.cpp
Then you can call the print function yourself for each solution (or only for the last one if that's what you need), and pass a std::ostream that writes to a file.
Cheers,
Guido
--
Guido Tack, http://people.cs.kuleuven.be/~guido.tack/
More information about the users
mailing list


Classes and interfaces
CheddarGetter_Client_AdapterInterface¶
Adapter interface for requesting the CheddarGetter service
« More »
CheddarGetter_Http_AdapterInterface¶
Adapter interface for getting and setting http related data
« More »
CheddarGetter_Client¶
Client object for interacting with the CheddarGetter service
« More »
CheddarGetter_Client_CurlAdapter¶
Adapter implementation based on php-curl for requesting the CheddarGetter service
« More »
CheddarGetter_Client_Exception¶
Client exception object
« More »
CheddarGetter_Client_ZendAdapter¶
Adapter implementation based on Zend_Http_Client for requesting the CheddarGetter service
« More »
CheddarGetter_Http_NativeAdapter¶
Adapter implementation using PHP superglobals for getting and setting http related data
« More »
CheddarGetter_Http_ZendAdapter¶
Adapter implementation using the ZF1 abstraction for getting and setting http related data
« More »
CheddarGetter_Response¶
Response object
« More »
CheddarGetter_Response_Exception¶
Response exception object
« More »


Class TrailAdapterRecyclerView.TrailsFilter
Filter takes searchview text and compares it to trails list
Inheritance
System.Object
TrailAdapterRecyclerView.TrailsFilter
Namespace: DigiTrailApp.Adapters
Assembly: DigiTrailApp.dll
Syntax
public class TrailsFilter : Filter
Constructors
View SourceTrailsFilter(TrailAdapterRecyclerView)
Declaration
public TrailsFilter(TrailAdapterRecyclerView adapter)
Parameters
| Type | Name | Description |
|---|---|---|
| TrailAdapterRecyclerView | adapter |
Methods
View SourcePerformFiltering(ICharSequence)
Declaration
protected override FilterResults PerformFiltering(ICharSequence constraint)
Parameters
| Type | Name | Description |
|---|---|---|
| ICharSequence | constraint |
Returns
| Type | Description |
|---|---|
| FilterResults |
PublishResults(ICharSequence, FilterResults)
Result
Declaration
protected override void PublishResults(ICharSequence constraint, FilterResults results)
Parameters
| Type | Name | Description |
|---|---|---|
| ICharSequence | constraint | ICharSequense |
| FilterResults | results | FilterResult |


First Post
Welcome to my new blog. My name is Christopher Diggins. I'm a software developer with an unhealthy obsession with programming languages and software engineering. Previously I've had blogs in different location across the interwebz:
- Area.Autodesk.com
- Artima.com
- O'Reilly
- MSDN
- Doctor Dobbs Journal
Programming and Software Development
Like most of my other blogs, the subject matter will be mostly related to programming and software development, and my adventures developing open-source librariesand programming languages. If you have ideas for blog topics, please send me a note.


{% extends "layout.html" %} {% block page_title %} GOV.UK prototype kit {% endblock %} {% block content %} You have successfully logged out. Click here to log back in. {% endblock %}
Click here to log back in.


Mark Hahn
Objective
SWE, SE, Researcher, Trilingual and Thinker based in Tokyo | ex-CircleCI, Mercari.
Education
Tokyo Institute of Technology - Tokyo, Japan
- Mar 2019
Master of Engineering (Transdisciplinary Science and Engineering)
Dongguk University - Seoul, Republic of Korea
- Aug 2016
Bachelor of Science in Computer Science and Engineering
Experience
Solutions Engineer at Circle Internet Service, Inc. (CircleCI) - Tokyo, Japan
May 2022 - Apr 2023
- Lead improvement of CI/CD design and processes with various companies based in APAC
- Support the technical implementation and day-to-day management of CircleCI Demonstrations and Trials, integrating our customers chosen technology stack
- Ensuring early customer success and a long-term business relationship
- Demonstrate and prove the technical feasibility of the CircleCI platform to highly technical audiences
- Build and launch new sales products and customer integrations to our internal teams and customer community
- Partner closely with our customer success teams to craft an outstanding customer experience for life
- Close the product feedback loop through our collaboration with Product and Engineering teams to help build product roadmaps based on market/customer requirements
- 2023/02: Application Strategy Summit NSW 2023 / CircleCI Exhibitor: introduce CircleCI as a CI/CD solution for various organisations such as government offices, enterprises, and tech companies.
- 2022/10: TECH WEEK SINGAPORE (Cloud Expo ASIA) / CircleCI Exhibitor: consulted and engaged in technical discussions with visitors who aim to improve their DevOps practices and software development lifecycles with better CI/CD strategies and automation.
- 2022/10: CircleCI's First Webinar for South Korea / Lead a technical webinar for the Korean market, got one of the most registrations and participants.
Senior Software Engineer, Microservices/Backend at Mercari, Inc. - Tokyo, Japan
Apr 2019 - May 2022
- designed, led and developed new projects into approx. 8M daily active user service
- migrated PHP monolithic API to Microservices with Golang and gRPC/Protobuf
- developed new microservices and managed to release to production
- shared knowledge internally/externally by attending tech conferences (GopherCon, gRPC Conf)
- created and conducted new software engineering training programme
- wrote and published several articles to company’s official blog, Mercan
- led a diversity community team and conducted several internal/external projects
- utilised Docker containers for development and deployment
- wrote automation tasks for continuous integration and continuous deployment
- learnt documenting code, version control using Git
- followed an agile development process including test-driven development, pair programming, and continuous releases
- wrote tests for the backend microservices
Software Engineer, Intern at Eventacular, Inc. - Tokyo, Japan
Mar 2018 - Jul 2018
- developed a web service frontend using React.js and Relay
- developed a web service backend using Phoenix (a Rails-like web framework written Elixir) and GraphQL
- wrote tests for the frontend and backend
- employed tools such as Pivotal Tracker, Slack, Github, and CircleCI
Activities & Awards
- ACM SIGCHI Communication Ambassador
- Master’s thesis Final Presentation GEDES Course Outstanding Presentation Award
- Science Communication for Global Talents, Oversea Programme with Science Museum, London, UK
- Teaching Assistant for Introduction to Society and Technology; Social Design Project; Software in the Future Society
- Several Tuition Scholarships; Japan Student Services Organization Scholarship
- the First Prize for graduation project by Dept. of Comp. Sci. and Eng.; Achievements, Excellence and the President’s Special Awards for undergraduate UAV (Unmanned Aerial Vehicle) project; paper published; patent registered;
Hobbies
- Street Photography with Rangefinder Camera and 35mm films
- Guitars and Guitar Pedals
- Learning new languages
Some Quotes
- Less is more.
- Get things done.
- Avoid success at all costs.


Next street:
?
Next turn:
? deg
Distance to turn:
? m
Distance to destination
? m
Time to next direction
? secs
Time to destination
? secs
Progress current direction (?)
Progress route (?)
Loaded track: none


--- layout: post status: publish published: true title: DSL Toolkit Information author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 162 wordpress_url: http://winterdom.com/2005/08/dsltoolkitinformation date: '2005-08-05 06:27:37 +0000' date_gmt: '2005-08-05 06:27:37 +0000' categories: - ".NET" tags: [] comments: [] ---
Does anyone know of any good articles and information on leveraging the DSL Toolkit for VS 2005? I've been looking to trying it out to experiment a bit with some ideas I have, but I'm ashamed to say I got up to defining a basic language and had no clue what to do after that :)


Robredo report on administration’s drug war not meant to disparage anyone
by Raymund AntonioVice President Leni Robredo has no intention to discredit anyone from the administration upon the release of her findings on the drug war after the 30th Southeast Asian (SEA) Games, her spokesperson assured.
Vice presidential spokesperson Barry Gutierrez said Robredo will publicly release her report on the anti-drug campaign that includes her recommendations to improve the government’s efforts.
“Hindi naman niya style iyong manira (It is not her style to discredit anyone),” Gutierrez, who is also a legal adviser to Robredo, said. “Hindi nga pumapatol iyan kapag siya iyong sinisiraan (She even doesn’t respond to those who discredit her).”
The former lawmaker gave the assurance during Robredo’s weekly radio show, “BISErbisyong Leni,” aired over local radio station dzXL.
Robredo deferred the release of her report from her short stint last month as co-chair of the Inter-agency Committee on Anti-Illegal Drugs (ICAD) at the conclusion of the country’s hosting of SEA Games which ends on December 11.
She wants to make public her findings and recommendations since President Rodrigo Duterte has yet to read the previous two reports she sent to Malacañang while she was the drug czar.
“We will make it public because it’s a waste if it just remains unread on his desk,” Robredo earlier said in Filipino.
According to Robredo, she would also release a third report about the drug war after the SEA Games.
On her radio show, Robredo’s spokesperson emphasized she would reveal “important information,” including her recommendations on “what she thinks needs to be improved” to contribute to the government’s anti-drug campaign.
”Kasi nagkakasundo naman tayong lahat na ito ay isang importanteng isyu na dapat nating pagtulungan, Gutierrez said.
(Since we all agree the illegal drug problem is an important issue that we should work on together.)
Duterte fired the lady official from the ICAD post, which she held for 19 days, for allegedly failing to perform her duties at the anti-drug body.
Malacañang said Robredo has committed “missteps,” such as her attempts to consult foreign individuals or organizations that have prejudged the drug war, her insistence to obtain classified information, and her tendency to share information to others.


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| ClasspathConfigurationProvider.PageLocator | PageLocator defines a locate method that can be used to discover server pages. |
| Class Summary | |
|---|---|
| BeanSelectionProvider | Selects the implementations of key framework extension points, using the loaded property constants. |
| ClasspathConfigurationProvider | ClasspathConfigurationProvider loads the configuration by scanning the classpath or selected packages for Action classes. |
| ClasspathConfigurationProvider.ClasspathPageLocator | ClasspathPathLocator searches the classpath for server pages. |
| DefaultPropertiesProvider | Loads the default properties, separate from the usual struts.properties loading |
| DefaultSettings | DefaultSettings implements optional methods of Settings. |
| DelegatingSettings | DelegatingSettings stores an internal list of Settings objects
to update settings or retrieve settings values. |
| LegacyPropertiesConfigurationProvider | |
| MethodConfigurationProvider | MethodConfigurationProvider creates ActionConfigs for potential action methods that lack a corresponding action mapping, so that these methods can be invoked without extra or redundant configuration. |
| NullResult | Null result to get around annotation defaults that can't be null |
| PropertiesSettings | A class to handle settings via a properties file. |
| ServletContextSingleton | This singleton holds an instance of the web servlet context. |
| Settings | Settings retrieves and exposes default values used by the framework. |
| StrutsXmlConfigurationProvider | Override Xwork class so we can use an arbitrary config file |
| Annotation Types Summary | |
|---|---|
| Namespace | Allows an action class to specify its namespace |
| ParentPackage | Allows an action class to specify an xwork package to inherit |
| Result | Defines an XWork Result |
| Results | Defines multiple XWork Results |
Classes for Struts configuration and property handling.
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


--- layout: default title: Home subtitle: My latest articles sitemap: priority: 0.9 ---
I am a Ph.D Student in machine learning applied to communication systems at Nokia Bell Labs, Paris Saclay, France, and recently graduated from INSA Lyon, France, with a MSc. in engineering.
Technology enthusiast for as long as I can remember, I discovered telecommunications in my infancy and machine learning at university.
I am now particularly interested in the physical layer, deep learning, reinforcement learning, and learning new skills when the need arises.
You can check my latest articles on the blog page, or download my résumé in the CV tab.
Other than that, I am found of photography, house music, and I try to go for a run when I have some spare time. You can know more about me in the About section.
Enjoy!


This is a phonetic keyboard layout for Gurmukhi. It is based on the ITRANS transliteration scheme by Avinash Chopde, with some minor modifications. This can be used for writing Punjabi and Sindhi languages. Examples: Type `hindI` for ਹਿਨ੍ਦੀ, `hiMdI` for ਹਿੰਦੀ,`gujarAtI` for ਗੁਜਰਾਤੀ, `paMjAbI` for ਪੰਜਾਬੀ.


Well, after a short hiatus of getting back to “real” work, I’m going to attempt to squeeze in another Spring Experience 2007 entry. This particular session was my first of Friday morning. I’ve always enjoyed Keith Donald as a speaker, having first heard him at TheServerSide.com’s Java In Action conference in 2005, and again during his Java University session at JavaOne 2007.
Keith began with a discussion of why we need patterns. In his opinion, patterns simply provide a way of thinking about a particular approach to a problem. One could liken them to blueprints. They typically have a name, a description of the problem being solved, a description of the solution approach, and finally a selection of implementation guidelines and considerations. Pretty nice summation.
The particular patterns that Keith planned to discuss surrounded the different data access patterns typically found in web applications.
Keith began by discussing the “Unit of Work” pattern, which he defined as a unit of interaction with a shared resource that executes independently of other units. These interactions exhibit ACID properties, and a database transaction provides a typical example. In the context of an ORM such as Hibernate, a Unit of Work tracks changes to the object graph during a transaction and then synchronizes those changes with the database when the transaction is complete. Keith followed this discussion with an implementation example from his “Reward Network” sample application.
Keith followed this discussion with two of what I’ll call “subpatterns” of the Unit of Work pattern: Pessimistic and Optimistic Locking. With pessimistic locking, you prevent other units from accessing your data during a given unit of work, and then release the “lock” as soon as possible. This locking is performed to prevent a race condition, resulting in an inconsistent state in your model. Keith briefly illustrated implementation of pessimistic locking with Hibernate.
It’s always interesting when someone asks a slightly off-topic question which ends up in a take home gem of information. At this point, someone asked if the implementations that Keith was showing showcased Spring’s Hibernate support. To this Keith surprised me by answering (and I paraphrase), “Hibernate’s native API’s are much more mature and powerful now, so we recommend you use those rather than Spring’s Hibernate API wrapper. Why add another dependency?” He then proceeded to recommend Rossen Stoyanchev’s Saturday morning session on “Working with Hibernate in a Spring 2.5 Environment” (blog entry to come later!). One of the better quotes of the conference came during this aside as well:
Whenever you can eliminate a dependency, you should.
- Keith Donald
Well, back to the presentation. Keith then moved into a discussion of Optimistic Locking. Here, within a business transaction that executes across a series of system transactions, you use optimistic locking to prevent corruption of shared data. An examples is where several users can edit account information concurrently, but the frequency of concurrent access is fairly low. Data integrity is still at risk, so you use optimistic locking to handle those infrequent cases. Keith them demonstrated the use of Hibernate versioning to implement optimistic locking.
Keith next moved into a discussion of the controversial “Open Session in View” pattern. This is a specialized technical pattern where by the Hibernate session is kept open for the duration of a given web request. It is generally used as a “quick fix” to prevent lazy loading exceptions in the view tier. This is generally considered a bad thing, as you end up with a great deal of “N+1 Select” situations while rendering the view, resulting in way too much SQL executed against the database. Typically, the need to use this pattern reveals a flaw in the design of your model or queries. For example, since you generally know how far in the object graph you’ll need to go for a specific view, you should load those relationships eagerly for that use case. You may also consider whether or not a given object association is appropriate to begin with.
The final major pattern that Keith discussed was the “Conversational Persistence Context” pattern that is present in the upcoming Spring Web Flow 2.0 release. It is essentially a more flexible variation of the Open Session in View pattern, where by you can have an open session spanning multiple requests during a long-running user interaction context, or “conversation.” To be perfectly honest, I still don’t quite “get” this pattern beyond that, probably because I don’t know much about Web Flow or it’s cousins (e.g. Seam, Web Beans JSR-299).
Keith closed with a very brief description of Master Detail, where you show an overview of objects in a collection and then allow drilling down into object details, and Paging, where you allow users to easily browse through a list of items of interest. I raised a point of contention with Keith at this point. His example implementation showed delegation of the paging concern to the DAO layer, rather than implementing that concern in the View layer. When I asked him where he thought it belonged, he thought it was obvious that it belonged in the DAO layer. I then let on that we had this debate in our team and decided the the concern belonged in the View layer. Why should I run the same query multiple times just to page through the data? Why not load the entire data set and then let the View tier decide how to page through it? Keith gracefully acknowledged my point.
All in all, this was a great session, if for no other reason than it reminded me of some best practices in this area and let me in on the little secret about using native Hibernate API’s rather than Spring’s Hibernate template. Nice job, Keith.


Part (collection of paths)
More...
#include <Dbs.h>
|
|
void | json (ostream &, bool pretty=false) |
| | See File::json.
|
| |
|
void | yaml (ostream &) |
| |
|
void | dxf (ostream &) |
| |
|
| static const string | quote (const string &) |
| | Quote string according to JSON rules. More...
|
| |
|
|
string | name |
| |
|
vector< Path > | paths |
| |
Part (collection of paths)
§ quote()
| const string dbs::Part::quote |
( |
const string & |
src | ) |
|
|
static |
Quote string according to JSON rules.
- Parameters
-
- Returns
- const string
The documentation for this struct was generated from the following files:
- Dbs.h
- dxf.cpp
- json.cpp
- yaml.cpp


We have received your email and will respond as quickly as we can! Make sure to enjoy listening to our new album Plexian in the meantime!


We're sorry but rent-admin doesn't work properly without JavaScript enabled. Please enable it to continue.


Mutiny on the Bounty (1935)
Grade: 94
"Mutiny on the Bounty" is an outstanding film, with excellent cast and cinematography, and an even better script. The film never flags for a moment, and all scenes work, whether dramatic, romantic or comic.
In late nineteenth century England, a ship is launched to Tahiti, to obtain breadfruit trees for feeding slaves on a British colony. Captain Bligh (Charles Laughton) is a brutal taskmaster, punishing his seamen even upon death. First Mate Fletcher Christian (Clark Gable) openly disapproves of Laughton's methods.
With both men stubborn and hot-tempered, conflict is inevitable. Gable takes the ship and sends Laughton off in a lifeboat with some loyal mates. Against all odds, Laughton makes it to England, and returns to the sea in a second ship to catch and hang the mutineers.
It is difficult to say what is more impressive: the cinematography of the big ships, cleverly giving the illusion of sailing the high seas, or the script, which gives the actors dramatic but natural lines.
I liked how events went after the mutiny. Laughton, who was selfish and cruel on the Bounty, is equally just and kindly on the lifeboat. This character transition was credible to me, because these were his loyal men, because it was what was needed to reach shore, and his anger was focused on seeing Grant hang.
Grant and the mutinous crew are hunted men without a country. Grant shows remorse for becoming an infamous outlaw, but no remorse for taking the ship to save lives and stop Laughton's cruelty.
Tahiti is depicted as a tropical paradise, with the most benevolent people (natives who look suspiciously anglo-saxon) in world history. Too bad civilizations like that cannot exist long, since it is ripe for exploitation by outsiders.
"Mutiny on the Bounty" won the Oscar for Best Picture. Laughton, Grant, and Franchot Tone (who plays a good-guy officer tried for mutiny) were all nominated for Best Actor, but must have split the votes between them.
<EMAIL_ADDRESS>http://members.tripod.com/~Brian_Koller/movies.html
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Young Traveller
"I share with you what I saw, heard and thought on my trips"
HOME
ABOUT
CONTACT
LOCATION
LOGIN
LOGOUT
See the world. It's more fantastic than any dream made or paid for in factories. Ask for no guarantees, ask for no security.


What data is there?¶
Each row in the CSV file is an object from the catalogue, and has a number of fields. There are:
- id_NUMBER:
- a unique identifier
- ITEM_NAME:
- a simple name, often from an established thesaurus
- TITLE:
- a short caption
- MAKER:
- the name of who made the object
- DATE_MADE:
- when the object was made, which may be a range, approximate date or unknown
- PLACE_MADE:
- where the object was made
- MATERIALS:
- what the object is made of
- MEASUREMENTS:
- the dimensions of the object
- DESCRIPTION
- a description of the object
- COLLECTION:
- the collection the object came from (eg: Science Museum - Space Technology)
There are obviously a number of different types of data here: free text, identifiers, dates, places (which could be geocoded to geo coordinates), and dimensions. Additionally, COLLECTION and MAKER both come from a list of possible values.


Rest in the woods
Literally lomo blue bottle pabst retro snackwave brooklyn taiyaki bitters. Stumptown tilde bespoke dreamcatcher enamel pin, pok pok blog drinking...
Read moreLiterally lomo blue bottle pabst retro snackwave brooklyn taiyaki bitters. Stumptown tilde bespoke dreamcatcher enamel pin, pok pok blog drinking...
Read moreBlue bottle pabst retro snackwave brooklyn taiyaki bitters. Stumptown tilde bespoke dreamcatcher enamel pin, pok pok blog drinking vinegar retro...
Read moreYou’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your...
Read more


The Others (2001) Nicole Kidman, Christopher Eccleston, Fionnula Flanagan, Elaine Cassidy, Eric Sykes, Alakina Mann, James Bentley, Rene Ascherson. Written and directed by Alejandro Amenábar. 104 minutes. Rated PG-13, 3 stars
Review by Ed Johnson-Ott, NUVO Newsweekly www.nuvo.net Archive reviews at http://reviews.imdb.com/ReviewsBy?Edward+Johnson-Ott To receive reviews by e-mail at no charge, send subscription requests to<EMAIL_ADDRESS>or e-mail<EMAIL_ADDRESS>with the word "subscribe" in the subject line.
It's hard not to recommend "The Others." The supernatural thriller, written and directed by Alejandro Amenábar ("Open Your Eyes"), adroitly establishes and maintains a low-key atmosphere of menace. The cinematography, by Javier Aguirresarobe, is as good as I have ever seen and Nicole Kidman gives another in her growing body of fine performances. But the pacing of the story moves from deliberate to downright sluggish and the payoff of the tale left me less than satisfied.
Overall, the film plays like a very high quality version of any number of old "Twilight Zone" episodes where the characters spend a great deal of time wandering about looking afraid and disoriented, only to learn they are actually a child's toy, a military test subject or a department store dummy. Watching those vintage shows and listening to the players chatter, I always wanted to shout, "Get on with it!" As much as I appreciated the atmosphere and acting in "The Others," my reaction was much the same.
Set at an island mansion off the coast of England during World War II, the story focuses on Grace (Kidman), who tends to her children Anne (Alakina Mann) and Nicholas (James Bentley) and worries about her husband, Charles (Christopher Eccleston), a missing serviceman. Anne and Nicholas suffer from photosensitivity and Grace patrols the estate with the keys to all 50 doors, protecting the little ones from excess light by making sure that only one door is open at a time.
At the beginning of the film, three servants, Mrs. Mills (Fionnula Flanagan), young, mute Lydia (Elaine Cassidy), and Mr. Tuttle (Eric Sykes), an aging gardener, join the family. The two that speak seem agreeable enough at first, but it soon becomes apparent that they know something that Grace does not. To make matters worse, the children are upset: Nicholas is unusually jittery and Anne claims to be seeing ghosts. Grace attempts to blame the troubles on the new arrivals to her home, only to realize that whatever is happening is beyond them.
That's essentially the whole story, with the tension growing until the pivotal moment when everything becomes clear. Earlier, there is an outstanding scene where Grace darts outside, only to be enveloped in fold after fold of shimmering fog. The visuals in the otherworldly sequence, courtesy of Aguirresarobe, are simply astounding.
I also enjoyed the presence of religion, a rarity in films dealing with the supernatural. Grace is a Christian and answers her children's questions about life and death with the assurance of a devout worshiper. When mother is away, though, the kids speculate whether her statements are fact or folklore, just as real children do.
But those nice touches fail to enliven a film that is too slow or make up for a lackluster ending. "The Others" sets out to be a classic ghost story, but fails to grasp that special something that makes such films more than layers of mist.
© 2001 Ed Johnson-Ott
========== X-RAMR-ID: 29121 X-Language: en X-RT-ReviewID: 242766 X-RT-TitleID: 1109257 X-RT-SourceID: 591 X-RT-AuthorID: 1099 X-RT-RatingText: 3/4
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


- My name is Raghad Alboriny 20 Years old
- I am a mother who have a diplome in pharmasy
- currently studying software development
- my favourite meal is waraq dwali
- and i am a cat person.
- In the future i want to combine my health domain whith programming to solve serious medical problems.
These are my top ten books to read:
- The Hunch back of Noterdam
- Animals Farm
- 1948
- The Time of white horses
- The Da vinci code
- Blindness
- Annee in the green hills
- Shadow of the wind
- Jane Eyre
- Great expectations


A testbed for looking at generalisation in sequence learning. The text is split into sentences at each period (.) and each sentence into words. The words are presented through a category encoder, i.e. with non-overlapping input bits.


I did not see a
dialog asking me to activate. In previous versions of Adobe software I was
explicitly prompted to activate. What has changed?
Activation
in Acrobat 9 and later products is easier to accomplish. Activation occurs silently
in the background.
You will
only receive a message if activation problems occur. For instance:
I see a message that says Iím unable to connect to the
Internet. Why?
The
application found that the connection to the Internet was either blocked or
unavailable. Check your network cable or wireless connection, and then launch
your web browser and navigate to a public website, for example, www.adobe.com, www.google.com,
or www.bbcnews.com. If you canít navigate
to any of these public sites, then you are not connected to the Internet.
Please check with your Internet service provider to fix the problem.
Iím able to connect to most sites on the Internet, but not
to
If you can
connect to public sites on the Internet, but you canít connect to
Iím still having
activation problems. Who can I contact?
Additional
information and details on activation are available at the Adobe Product Activation center.
You can
also contact an Adobe
Customer service agent to help you with your activation problem.


Napoli ordered into training camp, Ancelotti disagrees
MILAN, Nov 5 — Napoli coach Carlo Ancelotti does not agree with the club’s decision to confine his team to a so-called ‘ritiro’ for the next week but will have to go along with it, he said yesterday.
Ancelotti’s side have slipped to seventh in Serie A after taking only two points from their last three games, seriously damaging their chances of mounting another title challenge this season.
The club’s flamboyant president Aurelio De Laurentiis ordered the ‘ritiro’ — where a team is confined to a hotel or sometimes its own training base — yesterday following Saturday’s 2-1 defeat by AS Roma.
The ‘ritiro’ is a standard response to poor performances at Italian clubs although critics say it is outdated and makes highly paid professional players look like misbehaving school children.
“The club has taken this decision and we have to accept it. But, if you ask me if I agree, I would say no,” Ancelotti told reporters, adding that Napoli had run out of luck in their recent games.
“The results haven’t happened in this period, we have kept hitting the woodwork and we have paid a high price for some situations,” he said.
De Laurentiis told Naples-based Radio Kiss Kiss that his decision was not meant as a punishment. “It’s a chance for the team to get to know each other better,” he said.
Napoli’s next match is a home to Salzburg in the Champions League today, where results have been going better for Ancelotti’s team who top Group E — which also features Liverpool and Genk — with seven points.
“We’ve handled the Champions League well so far, let’s hope it continues,” he said. “The first aim is to get through the group, if we can do that with two games to spare, that would be great. I expect a change in fortunes, I’m confident.” — Reuters


Keychain
A simple inteferace for using the iOS Keychain, written in Swift. Heavily based on the work done by Jason Rendel in SwiftKeychainWrapper.
Provides singleton instance Keychain.default
that is setup to work for most needs.
If you need to customize the keychain access to use a custom identifier or access group, you can create your own instance instead of using the provided singleton.
By default, the Keychain saves data as a Generic Password type in the iOS Keychain. It saves items such that they can only be accessed when the app is unlocked and open. If you are not familiar with the iOS Keychain usage, this provides a safe default for using the keycain.
Users that want to deviate from this default implementation can specifiy keychain accessibility for each request (store, retrieve, etc…) to a Keychain instance.
Requirements
- Swift 5.0+
Notes
Keychain 0.1.2 is the last version that supports cocoapods Keychain 0.1.2 is the last release with Swift 4.2 support
Installation
Swift Package Manager
The Swift Package Manager is a tool for automating the distribution of Swift code and is integrated into the swift
compiler.
Once you have your Swift package set up, adding Keychain as a dependency is as easy as adding it to the dependencies
value of your Package.swift
.
dependencies: [
.Package(url: "https://github.com/rauhul/keychain.git", from: "0.2.0")
]
To use the keychain in your app, import Keychain into the file(s) where you want to use it.
import Keychain
General Usage
Store a string value to keychain:
let saveSuccessful = Keychain.default.store("exampleValue", forKey: "exampleKey")
Retrieve a string value from keychain:
let retrievedString = Keychain.default.retrieve(String.self, forKey: "exampleKey")
Delete a string value from keychain:
let removeSuccessful = Keychain.default.removeObject(forKey: "exampleKey")
Custom Instance
When the Keychain Wrapper is used, all keys are linked to a common identifier for your app, called the service name. By default this uses your main bundle identifier. However, you may also change it, or store multiple items to the keycahin under different identifiers.
To share keychain items between your applications, you may specify an access group and use that same access group in each application.
To set a custom service name identifier or access group, you may create your own keychain instance as follows:
let uniqueServiceName = "customServiceName"
let uniqueAccessGroup = "sharedAccessGroupName"
let customKeychainInstance = Keychain(serviceName: uniqueServiceName, accessGroup: uniqueAccessGroup)
The custom instance can then be used in place of the provided instance:
let saveSuccessful = customKeychainInstance.store("exampleValue", forKey: "exampleKey")
let retrievedString = customKeychainInstance.retrieve(String.self, forKey: "exampleKey")
let removeSuccessful = customKeychainInstance.removeObject(forKey: "exampleKey")
Accessibility Options
By default, all items saved to keychain can only be accessed when the device is unlocked. To change this accessibility, an optional “withAccessibility” param can be set on all requests. The enum Keychain.Accessibilty provides an easy way to select the accessibility level desired:
Keychain.default.store(<KeychainStorable>, forKey: "exampleKey", withAccessibility: .afterFirstUnlock)


Originally located at http://www.pphsg.org/cdsmith/types.html
, this article
explained some basic concepts of type systems. Unfortunately, that page is gone
and I had to fetch it from the web archive of that
page .
The note at the bottom states that contents are in the public domain. This was
published in 2008.
What follows is a short, brilliant introduction to the basic concepts of type systems, by Chris Smith.
What To Know Before Debating Type Systems
I would be willing to place a bet that most computer programmers have, on multiple occasions, expressed an opinion about the desirability of certain kinds of type systems in programming languages. Contrary to popular conception, that’s a great thing! Programmers who care about their tools are the same programmers who care about their work, so I hope the debate rages on.
There are a few common misconceptions, though, that confuse these discussions. This article runs through those I’ve encountered that obscure the most important parts of the debate. My goal is to build on a shared understanding of some of the basic issues, and help people get to the interesting parts more quickly.
Classifying Type Systems
Type systems are commonly classified by several words, of which the most common are “static,” “dynamic,” “strong,” and “weak.” In this section, I address the more common kinds of classification. Some are useful, and some are not.
Strong and Weak Typing
Probably the most common way type systems are classified is “strong” or “weak.” This is unfortunate, since these words have nearly no meaning at all. It is, to a limited extent, possible to compare two languages with very similar type systems, and designate one as having the strong*er* of those two systems. Beyond that, the words mean nothing at all.
Therefore: I give the following general definitions for strong and weak typing, at least when used as absolutes:
- Strong typing: A type system that I like and feel comfortable with
- Weak typing: A type system that worries me, or makes me feel uncomfortable
What about when the phrase is used in a more limited sense? Then strong typing, depending on the speaker or author, may mean anything on the spectrum from “static” to “sound,” both of which are defined below.
Static and Dynamic Types
This is very nearly the only common classification of type systems that has real meaning. As a matter of fact, its significance is frequently under-estimated. I realize that may sound ridiculous; but this theme will recur throughout this article. Dynamic and static type systems are two completely different things, whose goals happen to partially overlap.
A static type system is a mechanism by which a compiler examines source code and assigns labels (called “types”) to pieces of the syntax, and then uses them to infer something about the program’s behavior. A dynamic type system is a mechanism by which a compiler generates code to keep track of the sort of data (coincidentally, also called its “type”) used by the program. The use of the same word “type” in each of these two systems is, of course, not really entirely coincidental; yet it is best understood as having a sort of weak historical significance. Great confusion results from trying to find a world view in which “type” really means the same thing in both systems. It doesn’t. The better way to approach the issue is to recognize that:
- Much of the time, programmers are trying to solve the same problem with static and dynamic types.
- Nevertheless, static types are not limited to problems solved by dynamic types.
- Nor are dynamic types limited to problems that can be solved with static types.
- At their core, these two techniques are not the same thing at all.
Observing the second of these four simple facts is a popular pastime in some circles. Consider this set of presentation notes , with a rather complicated “the type system found my infinite loop” comment. From a theoretical perspective, preventing infinite loops is in a very deep sense the most basic possible thing you can do with static types! The simply-typed lambda calculus, on which all other type systems are based, proves that programs terminate in a finite amount of time. Indeed, the more interesting question is how to usefully extend the type system to be able to describe programs that don’t terminate! Finding infinite loops, though, is not in the class of things most people associate with “types,” so it’s surprising. It is, indeed, provably impossible with dynamic types (that’s called the halting problem; you’ve probably heard of it!). But it’s nothing special for static types. Why? Because they are an entirely different thing from dynamic types.
The dichotomy between static and dynamic types is somewhat misleading. Most languages, even when they claim to be dynamically typed, have some static typing features. As far as I’m aware, all languages have some dynamic typing features. However, most languages can be characterized as choosing one or the other. Why? Because of the first of the four facts listed above: many of the problems solved by these features overlap, so building in strong versions of both provides little benefit, and significant cost.
Other Distinctions
There are many other ways to classify type systems. These are less common, but here are some of the more interesting ones:
- Sound types. A sound type system is one that provides some kind of guarantee. It is a well-defined concept relating to static type systems, and has proof techniques and all those bells and whistles. Many modern type systems are sound; but older languages like C often do not have sound type systems by design; their type systems are just designed to give warnings for common errors. The concept of a sound type system can be imperfectly generalized to dynamic type systems as well, but the exact definition there may vary with usage.
- Explicit/Implicit Types. When these terms are used, they refer to the extent to which a compiler will reason about the static types of parts of a program. All programming languages have some form of reasoning about types. Some have more than others. ML and Haskell have implicit types, in that no (or very few, depending on the language and extensions in use) type declarations are needed. Java and Ada have very explicit types, and one is constantly declaring the types of things. All of the above have (relatively, compared to C and C++, for example) strong static type systems.
- The Lambda Cube. Various distinctions between static type systems are summarized with an abstraction called the “lambda cube.” Its definition is beyond the scope of this article, but it basically looks at whether the system provides certain features: parametric types, dependent types, or type operators. Look here for more information.
- Structural/Nominal Types. This distinction is generally applied to static types with subtyping. Structural typing means a type is assumed whenever it is possible to validly assume it. For example, a record with fields called x, y, and z might be automatically considered a subtype of one with fields x and y. With nominal typing, there would be no such assumed relationship unless it were declared somewhere.
- Duck Typing. This is a word that’s become popular recently. It refers to the dynamic type analogue of structural typing. It means that rather than checking a tag to see whether a value has the correct general type to be used in some way, the runtime system merely checks that it supports all of the operations performed on it. Those operations may be implemented differently by different types.
This is but a small sample, but this section is too long already.
Fallacies About Static and Dynamic Types
Many programmers approach the question of whether they prefer static or dynamic types by comparing some languages they know that use both techniques. This is a reasonable approach to most questions of preference. The problem, in this case, is that most programmers have limited experience, and haven’t tried a lot of languages. For context, here, six or seven doesn’t count as “a lot.” On top of that, it requires more than a cursory glance to really see the benefit of these two very different styles of programming. Two interesting consequences of this are:
- Many programmers have used very poor statically typed languages.
- Many programmers have used dynamically typed languages very poorly.
This section, then, brings up some of the consequences of this limited experience: things many people assume about static or dynamic typing that just ain’t so.
Fallacy: Static types imply type declarations
The thing most obvious about the type systems of Java, C, C++, Pascal, and many other widely-used “industry” languages is not that they are statically typed, but that they are explicitly typed. In other words, they require lots of type declarations. (In the world of less explicitly typed languages, where these declarations are optional, they are often called “type annotations” instead. You may find me using that word.) This gets on a lot of people’s nerves, and programmers often turn away from statically typed languages for this reason.
This has nothing to do with static types. The first statically typed languages were explicitly typed by necessity. However, type inference algorithms - techniques for looking at source code with no type declarations at all, and deciding what the types of its variables are - have existed for many years now. The ML language, which uses it, is among the older languages around today. Haskell, which improves on it, is now about 15 years old. Even C# is now adopting the idea, which will raise a lot of eyebrows (and undoubtedly give rise to claims of its being “weakly typed” -- see definition above). If one does not like type declarations, one is better off describing that accurately as not liking explicit types, rather than static types.
(This is not to say that type declarations are always bad; but in my experience, there are few situations in which I’ve wished to see them required. Type inference is generally a big win.)
Fallacy: Dynamically typed languages are weakly typed
The statement made at the beginning of this thread was that many programmers have used dynamically typed languages poorly. In particular, a lot of programmers coming from C often treat dynamically typed languages in a manner similar to what made sense for C prior to ANSI function prototypes. Specifically, this means adding lots of comments, long variable names, and so forth to obsessively track the “type” information of variables and functions.
Doing this prevents a programmer from realizing the benefits of dynamic typing. It’s like buying a new car, but refusing to drive any faster than a bicycle. The car is horrible; you can’t get up the mountain trails, and it requires gasoline on top of everything else. Indeed, a car is a pretty lousy excuse for a bicycle! Similarly, dynamically typed languages are pretty lousy excuses for statically typed languages.
The trick is to compare dynamically typed languages when used in ways that fit in with their design and goals. Dynamically typed languages have all sorts of mechanisms to fail immediately and clearly if there is a runtime error, with diagnostics that show you exactly how it happened. If you program with the same level of paranoia appropriate to C - where a simple bug may cause a day of debugging - you will find that it’s tough, and you won’t be actually using your tools.
(As a side comment, and certainly a more controversial one, the converse is equally true; it doesn’t make sense to do the same kinds of exhaustive unit testing in Haskell as you’d do in Ruby or Smalltalk. It’s a waste of time. It’s interesting to note that the whole TDD movement comes from people who are working in dynamically typed languages... I’m not saying that unit testing is a bad idea with static types; only that it’s entirely appropriate to scale it back a little.)
Fallacy: Static types imply upfront design or waterfall methods
Some statically typed languages are also designed to enforce someone’s idea of a good development process. Specifically, they often require or encourage that you specify the whole interface to something in one place, and then go write the code. This can be annoying if one is writing code that evolves over time or trying out ideas. It sometimes means changing things in several different places in order to make one tweak. The worst form of this I’m aware of (though done mainly for pragmatic reasons rather than ideological ones) is C and C++ header files. Pascal has similar aims, and requires that all variables for a procedure or function be declared in one section at the top. Though few other languages enforce this separation in quite the same way or make it so hard to avoid, many do encourage it.
It is absolutely true that these language restrictions can get in the way of software development practices that are rapidly gaining acceptance, including agile methodologies. It’s also true that they have nothing to do with static typing. There is nothing in the core ideas of static type systems that has anything to do with separating interface from implementation, declaring all variables in advance, or any of these other organizational restrictions. They are sometimes carry-overs from times when it was considered normal for programmers to cater to the needs of their compilers. They are sometimes ideologically based decisions. They are not static types.
If one doesn’t want a language deciding how they should go about designing their code, it would be clearer to say so. Expressing this as a dislike for static typing confuses the issue.
This fallacy is often stated in different terms: “I like to do exploratory programming” is the popular phrase. The idea is that since everyone knows statically typed languages make you do everything up front, they aren’t as good for trying out some code and seeing what it’s like. Common tools for exploratory programming include the REPL (read-eval-print loop), which is basically an interpreter that accepts statements in the language a line at a time, evaluates them, and tells you the result. These tools are quite useful, and they exist for many languages, both statically and dynamically typed. They don’t exist (or at least are not widely used) for Java, C, or C++, which perpetuates the unfortunate myth that they only work in dynamically typed languages. There may be advantages for dynamic typing in exploratory programming (in fact, there certainly are some advantages, anyway), but it’s up to someone to explain what they are, rather than just to imply the lack of appropriate tools or language organization.
Fallacy: Dynamically typed languages provide no way to find bugs
A common argument leveled at dynamically typed languages is that failures will occur for the customer, rather than the developer. The problem with this argument is that it very rarely occurs in reality, so it’s not very convincing. Programs written in dynamically typed languages don’t have far higher defect rates than programs written in languages like C++ and Java.
One can debate the reasons for this, and there are good arguments to be had there. One reason is that the average skill level of programmers who know Ruby is higher than those who know Java, for example. One reason is that C++ and Java have relatively poor static type systems. Another reason, though, is testing. As mentioned in the aside above, the whole unit testing movement basically came out of dynamically typed languages. It has some definite disadvantages over the guarantees provided by static types, but it also has some advantages; static type systems can’t check nearly as many properties of code as testing can. Ignoring this fact when talking to someone who really knows Ruby will basically get you ignored in turn.
Fallacy: Static types imply longer code
This fallacy is closely associated with the one above about type declarations. Type declarations are the reason many people associated static types with a lot of code. However, there’s another side to this. Static types often allow one to write much more concise code!
This may seem like a surprising claim, but there’s a good reason. Types carry
information, and that information can be used to resolve things later on and
prevent programmers from needing to write duplicate code. This doesn’t show up
often in simple examples, but a really excellent case is found in the Haskell
standard library’s Data.Map
module. This module implements a balanced binary
search tree, and it contains a function whose type signature looks like this:
lookup :: (Monad m, Ord k) => k -> Map k a -> m a
This is a magical function. It says that I can look something up in a Map
and
get back the result. Simple enough, but here’s the trick: what do I do if the
result isn’t there? Common answers might include returning a special “nothing”
value, or aborting the current computation and going to an error handler, or
even terminating the whole program. The function above does any of the above!
Here’s how I compare the result against a special nothing value:
case (lookup bobBarker employees) of
Nothing -> hire bobBarker
Just salary -> pay bobBarker salary
How does Haskell know that I want to choose the option of getting back
Nothing
when the value doesn’t exist, rather than raising some other kind of
error? It’s because I wrote code afterward to compare the result against
Nothing
! If I had written code that didn’t immediately handle the problem but
was called from somewhere that handled errors three levels up the stack, then
lookup
would have failed that way instead, and I’d be able to write seven or
eight consecutive lookup statements and compute something with the results
without having to check for Nothing
all the time. This completely dodges the
very serious “exception versus return value” debate in handling failures in
many other languages. This debate has no answer. Return values are great if you
want to check them now; exceptions are great if you want to handle them several
levels up. This code simply goes along with whatever you write the code to do.
The details of this example are specific to Haskell, but similar examples can be constructed in many statically typed languages. There is no evidence that code in ML or Haskell is any longer than equivalent code in Python or Ruby. This is a good thing to remember before stating, as if it were obviously true, that statically typed languages require more code. It’s not obvious, and I doubt if it’s true.
Benefits of Static Types
My experience is that the biggest problems in the static/dynamic typing debate occur in failing to understand the issues and potential of static types. The next two sections, then, are devoted to explaining this position in detail. This section works upward from the pragmatic perspective, while the next develops it into its full form.
There are a number of commonly cited advantages for static typing. I am going to list them in order from least to most significant. (This helps the general structure of working up to the important stuff.)
Performance
Performance is the gigantic red herring of all type system debates. The knowledge of the compiler in a statically typed language can be used in a number of ways, and improving performance is one of them. It’s one of the least important, though, and one of the least interesting.
For most computing environments, performance is the problem of two decades ago. Last decade’s problem was already different, and this decade’s problems are at least 20 years advanced beyond performance being the main driver of technology decisions. We have new problems, and performance is not the place to waste time.
(On the other hand, there are a few environments where performance still matters. Languages in use there are rarely dynamically typed, but I’m not interested enough in them to care much. If you do, maybe this is your corner of the type system debate.)
Documentation
If, indeed, performance is irrelevant, what does one look to next? One answer is documentation. Documentation is an important aspect of software, and static typing can help.
Why? Because documentation isn’t just about comments. It’s about everything that helps people understand software. Static type systems build ideas that help explain a system and what it does. They capture information about the inputs and outputs of various functions and modules. This is exactly the set of information needed in documentation. Clearly, if all of this information is written in comments, there is a pretty good chance it will eventually become out of date. If this information is written in identifier names, it will be nearly impossible to fit it all in. It turns out that type information is a very nice place to keep this information.
That’s the boring view. As everyone knows, though, it’s better to have self-documenting code than code that needs a lot of comments (even if it has them!). Conveniently enough, most languages with interesting static type systems have type inference, which is directly analogous to self-documenting code. Information about the correct way to use a piece of code is extracted from the code itself (i.e., it’s self-documenting), but then verified and presented in a convenient format. It’s documentation that doesn’t need to be maintained or even written, but is available on demand even without reading the source code.
Tools and Analysis
Things get way more interesting than documentation, though. Documentation is writing for human beings, who are actually pretty good at understanding code anyway. It’s great that the static type system can help, but it doesn’t do anything fundamentally new.
Fundamentally new things happen when type systems help computer programs to understand code. Perhaps I need to explain myself here. After all, a wise man (Martin Fowler, IIRC) one said:
“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”
I don’t disagree with Martin Fowler, but we have different definitions of understand in mind. Getting a computer to follow code step by step is easy. Getting a computer to analyze it and answer more complex questions about it is a different thing entirely, and it is very hard.
We often want our development tools to understand code. This is a big deal. I’ll turn back to Martin Fowler, who points this out as well .
Correctness
Ultimately, though, the justification for static typing has to come back to writing correct code. Correctness, of course, is just the program doing “what you want.”
This is a really tough problem; perhaps the toughest of all. The theory of computation has a result called Rice’s Theorem, which essentially says this: Given an arbitrary program written in a general purpose programming language, it is impossible to write a computer program that determines anything about the program’s output. If I’m teaching an intro to programming class and assign my students to write “hello world”, I can’t program a grader to determine if they did so or not. There will be some programs for which the answer is easy; if the program never makes any I/O calls, then the answer is no. If the program consists of a single print statement, it’s easy to check if the answer is yes. However, there will be some complicated programs for which my grader can never figure out the answer. (A minor but important technical detail: one can’t run the program and wait for it to finish, because the program might never finish!) This is true of any statement about programs, including some more interesting ones like “does this program ever finish?” or “does this program violate my security rules?”
Given that we can’t actually check the correctness of a program, there are two approaches that help us make approximations:
- Testing: establishes upper bounds on correctness
- Proof: establishes lower bounds on correctness
Of course, we care far more about lower bounds than upper bounds. The problem with proofs, though, is the same as the problem with documentation. Proving correctness is easy only somewhat insanely difficult when you have a static body of code to prove things about. When the code is being maintained by three programmers and changing seven times per day, maintaining the correctness proofs falls behind. Static typing here plays exactly the same role as it does with documentation. If (and this is a big if) you can get your proofs of correctness to follow a certain form that can be reproduced by machine, the computer itself can be the prover, and let you know if the change you just made breaks the proof of correctness. The “certain form” is called structural induction (over the syntax of the code), and the prover is called a type checker.
An important point here is that static typing does not preclude proving correctness in the traditional way, nor testing the program. It is a technique to handle those cases in which testing might be guaranteed to succeed so they don’t need testing; and similarly, to provide a basis from which the effort of manual proof can be saved for those truly challenging areas in which it is necessary.
Dynamic Typing Returns
Certainly dynamic typing has answers to this. Dynamically typed languages can sometimes perform rather well (see Dylan), sometimes have great tools (see Smalltalk), and I’m sure they occasionally have good documentation as well, though the hunt for an example is too much for me right now. These are not knock-down arguments for static typing, but they are worth being aware of.
The correctness case is particularly enlightening. Just as static types strengthened our proofs of correctness by making them easier and automatic, dynamic typing improves testing by making it easier and more effective. It simply makes the code fail more spectacularly. I find it amusing when novice programmers believe their main job is preventing programs from crashing. I imagine this spectacular failure argument wouldn’t be so appealing to such a programmer. More experienced programmers realize that correct code is great, code that crashes could use improvement, but incorrect code that doesn’t crash is a horrible nightmare.
It is through testing, then, that dynamically typed languages establish correctness. Recall that testing establishes only upper bounds on correctness. (Dijkstra said it best: “Program testing can be used to show the presence of bugs, but never to show their absence.“) The hope is that if one tries hard enough and still fails to show the presence of bugs, then their absence becomes more likely. If one can’t seem to prove any better upper bound, then perhaps the correctness really is 100%. Indeed, there is probably at some correlation in that direction.
What is a Type?
This is as good a point as any to step back and ask the fundamental question: what is a type? I’ve already mentioned that I think there are two answers. One answer is for static types, and the other is for dynamic types. I am considering the question for static types.
It is dangerous to answer this question too quickly. It is dangerous because we risk excluding some things as types, and missing their “type” nature because we never look for it. Indeed, the definition of a type that I will eventually give is extremely broad.
Problems with Common Definitions
One common saying, quoted often in an attempt to reconcile static and dynamic typing, goes something like this: Statically typed languages assign types to variables, while dynamically typed languages assign types to values. Of course, this doesn’t actually define types, but it is already clearly and obviously wrong. One could fix it, to some extent, by saying “statically typed languages assign types to expressions, ...” Even so, the implication that these types are fundamentally the same thing as the dynamic version is quite misleading.
What is a type, then? When a typical programmer is asked that question, they may have several answers. Perhaps a type is just a set of possible values. Perhaps it is a set of operations (a very structural-type-ish view, to be sure). There could be arguments in favor of each of these. One might make a list: integers, real numbers, dates, times, and strings, and so on. Ultimately, though, the problem is that these are all symptoms rather than definitions. Why is a type a set of values? It’s because one of the things we want to prove about our program is that it doesn’t calculate the square roots of a string. Why is a type a set of operations? It’s because one of the things we want to know is whether our program attempts to perform an impossible operation.
Let’s take a look at another thing we often want to know: does our web application stick data from the client into SQL queries without escaping special characters first? If this is what we want to know, then these become types. This article by Tom Moertel builds this on top of Haskell’s type system. So far, it looks like a valid definition of “type” is as follows: something we want to know.
A Type System
Clearly that’s not a satisfactory definition of a type. There are plenty of things we want to know that types can’t tell us. We want to know whether our program is correct, but I already said that types provide conservative lower bounds on correctness, and don’t eliminate the need for testing or manual proof. What makes a type a type, then? The other missing component is that a type is part of a type system.
Benjamin Pierce’s book Types and Programming Languages is far and away the best place to read up on the nitty gritty details of static type systems, at least if you are academically inclined. I’ll quote his definition.
A type system is a tractable syntactic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute.
This is a complex definition, but the key ideas are as follows:
- syntactic method .. by classifying phrases: A type system is necessarily tied to the syntax of the language. It is a set of rules for working bottom up from small to large phrases of the language until you reach the result.
- proving the absence of certain program behaviors: This is the goal. There is no list of “certain” behaviors, though. The word just means that for any specific type system, there will be a list of things that it proves. What it proves is left wide open. (Later on in the text: “... each type system comes with a definition of the behaviors it aims to prevent.“)
- tractable: This just means that the type system finishes in a reasonable period of time. Without wanting to put words in anyone’s mouth, I think it’s safe to say most people would agree that it’s a mistake to include this in the definition of a type system. Some languages even have undecidable type systems. Nevertheless, it is certainly a common goal; one doesn’t expect the compiler to take two years to type-check a program, even if the program will run for two years.
The remainder of the definition is mainly unimportant. The “kinds of values they compute” is basically meaningless unless we know what kinds we might choose from, and the answer is any kind at all.
An example looks something like this. Given the expression 5 + 3
, a type
checker may look at 5 and infer that it’s an integer. It may look at 3 and
infer it’s an integer. It may then look at the + operator, and know that when +
is applied to two integers, the result is an integer. Thus it’s proven the
absence of program behaviors (such as adding an integer to a string) by working
up from the basic elements of program syntax.
Examples of Unusual Type Systems
That was a pretty boring example, and one that plays right into a trap: thinking of “type” as meaning the same thing it does in a dynamic type system. Here are some more interesting problems being solved with static types.
- http://wiki.di.uminho.pt/twiki/pub/Personal/Xana/WebHome/report.pdf . Uses types to ensure that the correct kinds of data are gotten out of a relational database. Via the type system, the compiler ends up understanding how to work with concepts like functional dependencies and normal forms, and can statically prove levels of normalization.
- http://www.cs.bu.edu/~hwxi/academic/papers/pldi98.pdf . Uses an extension to ML’s type system to prove that arrays are never accessed out of bounds. This is an unusually hard problem to solve without making the languages that solve it unusable, but it’s a popular one to work on.
- http://www.cis.upenn.edu/~stevez/papers/LZ06a.pdf . This is great. This example uses Haskell’s type system to let someone define a security policy for a Haskell program, in Haskell, and then proves that the program properly implements that security. If a programmer gets security wrong, the compiler will complain rather than opening up a potential security bug in the system.
- http://www.brics.dk/RS/01/16/BRICS-RS-01-16.pdf . Just in case you thought type systems only solved easy problems, this bit of Haskell gets the type system to prove two central theorems about the simply typed lambda calculus, a branch of computation theory!
The point of these examples is to point out that type systems can solve all sorts of programming problems. For each of these type systems, concepts of types are created that represent the ideas needed to accomplish this particular task with the type system. Some problems solved by static type systems look nothing like the intuitive idea of a type. A buggy security check isn’t normally considered a type error, but only because not many people use languages with type systems that solve that problem.
To reiterate the point above, it’s important to understand how limiting it is to insist, as many people do, that the dynamic typing definition of a “type” is applied to static typing as well. One would miss the chance to solve several real-world problems mentioned above.
The True Meaning of Type
So what is a type? The only true definition is this: a type is a label used by a type system to prove some property of the program’s behavior. If the type checker can assign types to the whole program, then it succeeds in its proof; otherwise it fails and points out why it failed. This is a definition, then, but it doesn’t tell us anything of fundamental importance. Some further exploration leads us to insight about the fundamental trade-offs involved in using a static type checker.
If you were looking at things the right way, your ears may have perked up a few sections back, when I said that Rice’s Theorem says we can’t determine anything about the output of a program. Static type systems prove properties of code, but it almost appears that Rice’s Theorem means we can’t prove anything of interest with a computer. If true, that would be an ironclad argument against static type systems. Of course, it’s not true. However, it is very nearly true. What Rice’s Theorem says is that we can’t determine anything. (Often the word “decide” is used; they mean the same thing here.) It didn’t say we can’t prove anything. It’s an important distinction!
What this distinction means is that a static type system is a conservative estimate. If it accepts a program, then we know the program has the properties proven by that type checker. If it fails... then we don’t know anything. Possibly the program doesn’t have that property, or possibly the type checker just doesn’t know how to prove it. Furthermore, there is an ironclad mathematical proof that a type checker of any interest at all is always conservative. Building a type checker that doesn’t reject any correct programs isn’t just difficult; it’s impossible.
That, then, is the trade-off. We get assurance that the program is correct (in the properties checked by this type checker), but in turn we must reject some interesting programs. To continue the pattern, this is the diametric opposite of testing. With testing, we are assured that we’ll never fail a correct program. The trade-off is that for any program with an infinite number of possible inputs (in other words, any interesting program), a test suite may still accept programs that are not correct - even in just those properties that are tested.
Framing the Interesting Debate
That last paragraph summarizes the interesting part of the debate between static and dynamic typing. The battleground on which this is fought out is framed by eight questions, four for each side:
- For what interesting properties of programs can we build static type systems?
- How close can we bring those type systems to the unattainable ideal of never rejecting a correct program?
- How easy can it be made to program in a language with such a static type system?
- What is the cost associated with accidentally rejecting a correct computer program?
- For what interesting properties of programs can we build test suites via dynamic typing?
- How close can we bring those test suites to the unattainable ideal of never accepting a broken program?
- How easy can it be made to write and execute test suites for programs?
- What is the cost associated with accidentally accepting an incorrect computer program?
If you knew the answer to those eight questions, you could tell us all, once and for all, where and how we ought to use static and dynamic typing for our programming tasks.


my span Link Link Link Link
this & that and mu = μ
<not a tag>
line break line break
$ echo one one bash$ echo two two ~/git/oilshell/oil$ echo three three


Amazon says it uses aggregated seller data to help business
Amazon uses “aggregated data” from sellers in its third-party marketplace to improve its overall business, the online retailer said in response to a congressional antitrust probe.
Such data, also culled from public sources and Amazon’s first-party sales, is available to the company’s retail and private brand teams, the company said in an Oct. 11 document released by the US House of Representatives Judiciary Committee on Tuesday, Reuters reports.
Data on individual sellers is not used to improve Amazon’s business, the company said, adding that its teams do not use seller data to launch, source or price private label products, which number about 158,000.
The comments came as the US congressional panel is investigating potential breaches of antitrust law by big technology companies.
The e-commerce behemoth said use of public and aggregated sales data to spot in-demand products is standard practice in retailing.
Amazon also said it may ask third-party merchants to lower prices on Amazon.com when it finds the sellers asking for less on a competing website.
Asked how it ranks shopping results on its website, Amazon said its algorithm does not consider factors such as whether it has a competing private label brand, if a competing third-party seller has purchased ads, or if the seller is enrolled in Amazon’s logistics program.
It instead considers a product’s availability, price and how frequently it was purchased.
– Contact us at<EMAIL_ADDRESS>RC


27th April 2015
Hi Everyone,
My name is Rabi C Shah. I am from Nepal and as you may have heard my country has suffered an unimaginable tragedy. The earthquake left my country, in ruins with about 4000+ dead throughout the country and is expected to go up as dust settles after this devastation. Thousands have been injured, countless have lost home. My family is safe but others were not so lucky.
I am making this personal request to you if there is anything you can do to help those in needs. By donating to either of these funds, or some other relief effort based on your informed judgement and financial capacity, you will help my nation cope the aftermaths of this disaster. Every money counts and no financial support is small.
Please feel free to contact me if you have any queries.
Please circulate this information to anybody who you think might offer some help.
Thank You,
Rabi C Shah


Josip Faletar
Ferit
DRD
Gallery
Three pictures
Ferit gallery
Logo
This is the logo of the Ferit
This is the logo of the Ferit.
This is the logo of the Ferit
Header
Best picture
This is paragraph
Button
Search google maps
Place name:Some information:


setext headers-
first level
===========
second level
------------
not a header
------------
atx headers-
# first level
## second level
###### sixth level
# first level closed #
### third level closed unevenly ######
rules -
* * *
***
*****
- - - - -
______________________