lake
is a build engine written in Lua, similar to Ruby's rake
. It is not a makefile generator, but evaluates dependencies directly - that is, it is an interpreter of dependency rules, not a makefile compiler. This is a sensible design decision because lake
is small (about 50K pure Lua, 250K together with Lua and LuaFileSystem) enough to carry around.
Apart from being quick & compact, these are the features of interest:
GCC
and Microsoft Visual C++ compilers, and does cross-platform buildslake
as a Compiler Front-endGenerally, build rules for lake
are expressed in lakefiles, which are Lua scripts. But it is possible to use lake
directly on a source file. Consider this simple C program:
$> cat hello.c
#include <stdio.h>
int main(int argc, char **argv)
{
int i;
printf("hello, world!\n");
for (i = 0; i < argc; ++i) {
printf("%d %s\n",i,argv[i]);
}
return 0;
}
Passing this as an argument to lake
causes the program to be compiled, linked and then run:
$> lake hello.c
cl /nologo -c /O1 /showIncludes hello.c
link /nologo hello.obj /OUT:hello.exe
hello.exe
hello, world!
0 hello.exe
Thereafter, the program is up-to-date and will not be rebuilt until the source file changes.
$> lake hello.c one two three
hello.exe one two three
hello, world!
0 hello.exe
1 one
2 two
3 three
On Windows, the Microsoft compiler is the default, if it is found on the path, but it is straightforward to override the compiler on the command line:
$> lake CC=gcc hello.c one two three
gcc -c -O1 -MMD hello.c
gcc hello.o -o hello.exe
hello.exe one two three
hello, world!
0 hello.exe
1 one
2 two
3 three
On Linux, we default to using gcc:
$ lake hello.c
gcc -c -O1 -MMD hello.c
gcc hello.o -o hello
./hello
hello, world!
0 ./hello
lake
Like make
, lake
looks for a file called 'lakefile'. Simularly, you can say lake -f any.lake
where any.lake
contains the lakefile commands.
Typing lake --help
gives some more options. -d
is followed by a directory, and means 'change to that directory and run'. -t
is useful for testing; it will show the commands but won't execute them.
-s
means 'strict compile'; uses '-pedantic -Wall' for GCC
; '/WX' for CL
. Alternatively, you can set STRICT=true
at the start of your lakefile.
How to customize the operation of lake
itself? There are several ways (in order of evaluation):
LAKE_PARMS
exists, then it's assumed to contain VAR=VALUE
pairs separated by semi-colonsVAR=VALUE
(as with Make)lakeconfig
is found in the current directory, it will then be loaded ~/.lake/config
exists, it will read. (On Windows, ~
is your home directory like C:\Documents and Settings\SJDonova
or C:\Users\sdonovan
)require 'mymodule'
in your lakefile.The simplest hello-world lakefile is straightforward; it builds a C program named 'hello', with no explicit source files, so we use the program name:
$> cat lakefile
c.program{'hello'}
$> lake
gcc -c -O1 -MMD hello.c
gcc hello.o -o hello.exe
This lakefile automatically understands a 'clean' target, and the -g
option forces a debug build:
$> lake clean
removing hello.exe
removing hello.o
$> lake -g
gcc -c -g -MMD hello.c
gcc hello.o -o hello.exe
(You can achieve the same effect as -g
by passing DEBUG=true
on the command-line)
If cl.exe is on your path, then we would get:
$> lake -g
cl /nologo -c /Zi /showIncludes hello.c
link /nologo hello.obj /OUT:hello.exe
lake
knows the common flags that these compilers use to achieve common goals - in this case, a debug build. This places less stress on human memory (which is not a renewable resource) especially if you are working with a compiler which is foreign to you.
Now, what if hello.c
had a call to a math function? No problem with Windows (it's part of the C runtime) but on Unix it is a separate library. A lakefile that expresses this need is:
c.program{'hello',needs='math'}
On Unix, we will now get the necessary -lm
. All this can be done with a makefile, but it would already be an irritating mess, even if it just handled GCC
alone. The purpose of lake
is to express build rules in a high-level, cross-platform way.
Note here that we have been implicitly using a cool Lua feature, which is that a function call does not need parens if the single argument is a table. Lua does not support named arguments as such, but the table syntax is very flexible and does the same job elegantly.
The next step is multi-file programs. In examples/first
:
$> cat lakefile
c.program{'first',src='one,two',needs='math'}
$> lake
gcc -c -O1 -MMD one.c
gcc -c -O1 -MMD two.c
gcc one.o two.o -o first.exe
Here the source files are explicitly defined by the src
parameter (without extension), and the project name continues to define the name of the output file.
This simple lakefile does dependency checking; if a source file changes, then it is recompiled, and the program is relinked since it depends on the output of the compilation. We don't need to rebuild files that have not changed.
$> touch one.c
$> lake
gcc -c -O1 -MMD one
gcc one.o two.o -o first.exe
Actually, lake
goes further than this. Both one.c
and two.c
depend on common.h
; if you modify this common dependency, then both source files are rebuilt. This is done because lake
knows about the GCC
-MMD
flag, which generates a file containing the non-system header files encountered during compilation:
$> cat one.d
one.o: one.c common.h
One tiresome aspect of constructing robust makefiles is explicitly listing the dependencies. (This is not a criticism of make
, which does what it does well, and it does not pretend to understand the tools it is running, whereas lake
has been designed to be very tool-aware for your convenience.) This also works for the CL
compiler using the somewhat obscure /showIncludes
flag.
So the lakefiles for even fairly large code bases can be short and sweet. In examples/big1
there are a hundred generated .c files, with randomly assigned header dependencies:
$> cd examples/big1
$> cat lakefile
c.program {'name',src='*'}
Here src
is a wildcard, again assuming an extension of .c
for C files. The initial build takes some time, but thereafter rebuilding is quick.
By default, lake
tries to compile as many files as it can with one compiler invocation. Both GCC
and CL
support this, but not if you have explicitly specified an output directory. The global NO_COMBINE
can be used to switch off this attempt to be helpful.
Building a target often requires particular system libraries. For equivalent functionality, these libraries may be different. For the example above, a Linux program needs libm.a
if it wants to link to fabs
and sin
etc, but a Windows program does not. We express this as the need 'math' and let lake
sort it out. Other common Linux needs are 'dl' if you want to load dynamic libraries directly using dlopen
. On the other side, Windows programs need to link against wsock32
to do standard Berkerly-style sockets programming; the need 'sockets' expresses this portably. The need 'readline' is superfluous on Windows, since the shell provides much of this functionality out of the box, and on Linux it also implies linking against ncurses
and history
; on OS X linking against readline
is sufficient.
There are also two predefined needs for GTK+ programming: 'gtk' and 'gthread'. These are implemented using pkg-config
which returns the include directories and libraries necessary to build against these packages.
If a need is unknown, then lake
assumes that pkg-config
knows about it. For instance, installing the computer vision library OpenCV updates the package database:
$ pkg-config --cflags --libs opencv
-I/usr/local/include/opencv -L/usr/local/lib -lcxcore -lcv -lhighgui -lcvaux -lml
Needs can be specified by the NEEDS
global variable. If I wanted to build a program with OpenCV, I can either say:
$ lake NEEDS=opencv camera.c
or I can make all programs in a directory build with this need by creating a file lakeconfig
with the single line:
NEEDS = 'opencv'
and then lake camera.c
will work properly.
If program
has a field setting odir=true
then it will put output files into a directory release
or debug
depending if this is was a release or debug build (-g
or DEBUG=true
.)
This is obviously useful when switching between build versions, and can be used to build multiple versions at once. See `examples/releases' - the lakefile is
-- maintaining separate release & debug builds
PROG={'main',src='../hello',odir=true}
release = c.program(PROG)
set_flags {DEBUG=true}
debug = c.program(PROG)
default{release,debug}
Please note that global variables affecting the build should be changed using set_flags()
This feature naturally interacts with cross-compilation. If the global PREFIX
was set to arm-linux
then the compiler becomes arm-linux-gcc
etc. The release directory would become arm-linux-release
.
odir
can explicitly be set to a directory name. Due to tool limitations, lake
cannot combine multiple files in a single compilation if odir
is set.
Unix shared libraries and Windows DLLs are similar, in the sense that both orcas and sharks are efficient underwater predators but are still very different animals.
Consider lib1.c
in examples/lib1
; the lakefile is simply:
c.shared {'lib1'}
which results in the following compilation:
gcc -c -O1 -MMD lib1.c
gcc lib1.o -shared -o lib1.dll
(Naturally, the result will be lib1.so
on Unix.)
By default, GCC
exports symbols; using the MS tool dumpbin
on Windows reveals that the function answer
is exported. However, CL
does not. You need to specify exports explicitly, either by using the __declspec(dllexport)
decoration, or with a DEF file:
$> cat lib1.def
LIBRARY lib1.dll
EXPORTS
answer
$> lake
cl /nologo -c /O1 /showIncludes lib1.c
link /nologo lib1.obj /DEF:lib1.def /DLL /OUT:lib1.dll
Creating library lib1.lib and object lib1.exp
So on Windows, if there is a file with the same name as the DLL with extension .def, then it will be used in the link stage automatically.
(Most cross-platform code tends to conditionally define EXPORT
as __declspec(dllexport)
which is also understood by GCC
on Windows.)
There is a C program needs-lib.c
which links dynamically against lib1.dll
. The lakefile that expresses this dependency is:
lib = c.shared {'lib1'}
c.program{'needs-lib1',lib}
Which results in:
gcc -c -O1 -MMD needs-lib1.c
gcc -c -O1 -MMD lib1.c
gcc lib1.o lib1.def -shared -o lib1.dll
gcc needs-lib1.o lib1.dll -o needs-lib1.exe
In this lakefile, the result of compiling the DLL (its target) is added as an explicit dependency to the C program target. GCC
can happily link against the DLL itself (the recommended practice) but CL
needs to link against the 'import library'. Again, the job of lake
is to know this kind of thing.
This is an example where different compilers behave in different ways, and is a story of awkward over-complication. On Unix, programs link dynamically against the C runtime (libc) unless explicitly asked not to, whereas CL
links statically. To link a Unix program statically, add static=true
to your program options; to link a Windows CL
program dynamically, add dynamic=true
.
It is tempting to force consistent operation, and always link dynamically, but this is not a wise consistency, because since 2005, CL
will then link against msvcr80.dll
, msvcr90.dll
and so on which in effect you will have to redistribute with your application anyway, either as a private side-by-side assembly or via VCDist
.
Here is the straight CL
link versus the dynamic build for comparison:
link /nologo test1.obj /OUT:test1.exe
link /nologo test1.obj msvcrt.lib /OUT:test1.exe && mt -nologo -manifest test1.e
xe.manifest -outputresource:test1.exe;1
The first link gives a filesize of 48K, versus 6K for the second. But the dynamically linked executable has an embedded manifest which is only satisfied by the particular version of the runtime for that version of CL
(and it is picky about sub-versions as well.) - so you have to copy that exact DLL (msvcr80.dll, msvcr90.dll, depending) into the same directory as your executable, and redistribute it alongside. So the size savings are only worth it for larger programs which ship with a fair number of DLLs. This is (for instance) the strategy adopted by Lua for Windows.
lake
has special support for building Lua C/C++ extensions. In examples/lua
there is this lakefile:
c.shared{'mylib',lua=true}
And the build is:
gcc -c -O1 -MMD -Ic:/lua/include mylib.c
gcc mylib.o mylib.def -Lc:/lua/lib -llua5.1 -shared -o mylib.dll
lake
will attempt to auto-detect your Lua installation, which can be a little hit-and-miss on Windows if you are not using Lua for Windows. It may be necessary to set LUA_INCLUDE
and LUA_LIBDIR
explicitly.
On Linux with a 'canonical' Lua install, things are simpler:
gcc -c -O1 -MMD -fPIC mylib.c
gcc mylib.o -shared -o mylib.so
On Debian/Ubuntu, liblua5.1-dev puts the include files in its own directory:
gcc -c -O1 -MMD -I/usr/include/lua5.1 -fPIC mylib.c
gcc mylib.o -shared -o mylib.so
With Lua for Windows, you have to be a little careful about the runtime dependency for non-trivial extensions. LfW uses the VC2005 compiler, so either get this, or use GCC
with LIBS='-lmsvcr80'. (It is also possible to configure Mingw so that it links against libmsvcr80.a
by default.) The situation you are trying to avoid is having multiple run-tiime dependencies, since this will bite you because of imcompatible heap allocators.
The lua=true
option also applies to programs embedding Lua. It is actually recommended to link such programs against the shared library across platforms, to ensure that the whole Lua API is available.
Consider the case where there are several distinct groups of source files, with different defines, include directories, etc. For instance, some files may be C, some C++, for instance the project in examples/main
. One perfectly good approach is to build a static libraries for distinct groups:
lib = c.library{'lib'}
cpp.program{'main',lib}
(It may seem silly to have a library containing exactly one object file, but you are asked to imagine that there are dozens or maybe even hundreds of files.)
This lakefile shows how this can also modelled with groups;
main = cpp.group{'main'}
lib = c.group{'lib'}
cpp.program{'main',inputs={main,lib}}
There is main.cpp and lib.c, and they are to compiled separately and linked together.
program
normally constructs a compile rule and populates it using the source, even if it is just inferred from the program name. Any options that only make sense to the compile rule get passed on, like incdir
or defines
. But if inputs
is specified directly, then program
just does linking. group
, on the other hand, never does any linking, and can only understand options for the compile stage.
Lua is not a difficult language to build from source, but there are a number of subtleties involved. For instance, it is built as a standalone executable with exported symbols on Unix, and as a stub program linked against a DLL on Windows. Here is the lakefile, section by section:
LUA='lua'
LUAC='luac print'
as_dll = WINDOWS
if as_dll then
defs = 'LUA_BUILD_AS_DLL'
end
if not WINDOWS then
defs = 'LUA_USE_LINUX'
end
The first point (which should not come as too much of a suprise) is that this is actually a Lua program. All the power of the language is available in lakefiles. lake
sets some standard globals like WINDOWS and PLAT.
-- build the static library
lib,ll=c.library{'lua',src='*',exclude={LUA,LUAC},defines=defs}
The Lua static library (.a
or .lib
) is built from all the C files in the directory, except for the files corresponding to the programs lua
and luac
. Depending on our platform, we also have to set some preprocessor defines.
-- build the shared library
if as_dll then
libl = c.shared{'lua',inputs=ll,dynamic=true}
else
libl = lib
end
On Windows (or Unix if we wanted) a DLL is built as well as a static library. This DLL shares the same inputs as the static library - these are the second thing returned by the first library
call. The dynamic
option forces the DLL to be dynamically linked against the runtime (this is not true by default for CL
.)
-- build the executables
lua = c.program{'lua',libl,src=LUA,needs='dl math readline',export=not as_dll,dynamic=true}
luac = c.program{'luac',lib,src=LUAC,needs='math'}
default {lua,luac}
The lua
program either links against the static or the dynamic library; if statically linked, then it has to export its symbols (otherwise Lua C extensions could not find the Lua API symbols). Again, always link against the runtime (dynamic
).
This executable needs to load symbols from shared libraries ('dl'), to support interactive command-line editing ('readline') and needs the maths libraries ('math'). Expressing as needs simplifies things enormously, because lake
knows that a program on Linux that needs 'readline' will also need to link against 'history' and 'ncurses', whereas on OS X it just needs to link against 'readline'. On Windows, the equivalent functionality is part of the OS.
The luac
program always links statically.
Finally, we create a target with name 'default' which depends on the both of these programs, so that typing 'lake' will build everything.
Expressing the Lua build as a lakefile makes the build intents and strategies clear, whereas it would take you a while to work these out from the makefile itself It also is inherently more flexible; it works for both CL
and GCC
, a debug build just requires -g
and it can be persuaded easily to give a .so
library on Unix.
Although in many ways an easier language to learn initially than C, C++ is sometimes its own worst enemy. The extensive use of templates in Boost and the standard library can make error messages painful to understand at first.
Consider the following silly C++ program (and remember that we start by writing silly programs):
// errors.cpp
#include <iostream>
#include <string>
#include <list>
using namespace std;
int main()
{
list<string> ls;
ls.append("hello");
cout << "that's all!" << endl;
return 0;
}
The original error message is:
errors.cpp:9: error: 'class std::list<std::basic_string<char, std::char_traits<char>, std::allocator<char> >,
std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >' has no member named
'append'
Seasoned C++ programmers learn to filter their error messages mentally. lake
provides the ability to filter the output of a compiler, and reduce irrelevant noise. Here is the lakefile:
if CC ~= 'g++' then quit 'this filter is g++ specific' end
output_filter(cpp,function(line)
return line:gsub('std::',''):
gsub('basic_string%b<>','string'):
gsub(',%s+allocator%b<>',''):
gsub('class ',''):gsub('struct ','')
end)
cpp.program {'errors'}
And now the error is reduced to:
errors.cpp:9: error: 'list<string >' has no member named 'append'
We have thrown away information, true, but it is implementation-specific stuff which is likely to confuse and irritate the newcomer.
Such an output filter can be added to ~/.lake/config
or brought explicitly in with require 'cpp-error'
and becomes available to all of your C++ projects.
There are tasks other than program building which can benefit from dependency checking. For instance, say I have a number of jpegs and Markdown files which I wish to convert into PNG and HTML respectively. We construct a rule, which maps files of one extension onto files of another extension, using a command. We populate the rule with targets, and then use the 'default' target to make sure that these targets are checked.
to_png = rule('.jpg','.png',
'convert $(INPUT) $(TARGET)' -- uses ImageMagick
)
to_html = rule('.md','.html',
'lua /dev/lua/FAQ/markdown.lua $(INPUT)'
)
default {to_png '*', to_html '*'}
Calling rule objects generates targets, using a filename or a wildcard.
(This example isn't meant to be portable, just an efficient way to solve a specific problem.)
Martin Fowler has an article on using Rake for managing tasks with dependencies. Here is his first rakefile:
task :codeGen do
# do the code generation
end
task :compile => :codeGen do
#do the compilation
end
task :dataLoad => :codeGen do
# load the test data
end
task :test => [:compile, :dataLoad] do
# run the tests
end
This lakefile is equivalent:
task = target
task('codeGen',nil,function()
print 'codeGen'
end)
task('compile','codeGen',function()
print 'compile'
end)
task('dataLoad','codeGen',function()
print 'dataLoad'
end)
task('test','compile dataLoad',function()
print 'test'
end)
Try various commands like 'lake compile' and 'lake test' to see how the actions are called.
You may find Lua's anonymous function syntax a little noisy. But there's nearly always another way to do things in Lua. This style is probably more natural for Lua programmers:
-- fun.lua
actions,deps = {},{}
function actions.codeGen ()
print 'codeGen'
end
deps.compile = 'codeGen'
function actions.compile ()
print 'compile'
end
deps.dataLoad = 'codeGen'
function actions.dataLoad ()
print 'dataLoad'
end
deps.test = 'compile dataLoad'
function actions.test ()
print 'test'
end
for name,fun in pairs(actions) do
target(name,deps[name],fun)
end
default 'test'
An entertaining aspect to this style of programming is that the order of the dependencies firing is fairly arbitrary (except that the sub-dependencies must fire first) so that they could be done in parallel.
I have a feeling that there is a small, compact dependencies library buried inside lake.lua
in the same way that there is a thin athletic person inside every fat couch potato. To do its job without external dependencies, lake
defines a lot of useful functionality which can be used for other purposes. Also, these facilities are very useful within more elaborate lakefiles.
In the same directory as lake.lua
, we can load it as a module:
$ lua -llake
Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio
> t = expand_args('*','.c',true)
> = #t
112
> for i = 1,10 do print(t[i]) end
examples/hello.c
examples/test1/src/test1.c
examples/first/one.c
examples/first/two.c
examples/lib1/needs-lib1.c
examples/lib1/lib1.c
examples/lua/mylib.c
examples/big1/c087.c
examples/big1/c014.c
examples/big1/c007.c
expand_args
is a file grabber which recursively looks into directories, if the third parameter is true
.
> for s in list {'one','two','three'} do print(s) end
one
two
three
list
can also be passed a space-or-comma separated string. There are other useful functions for working with lists and tables:
> ls = {1,2}
> append_list(ls,{3,4})
> forall(ls,print)
1
2
3
4
> = index_list({10,20,30},20)
2
> ls = {ONE=1}
> append_table(ls,{TWO=2,THREE=3})
> for k,v in pairs(ls) do print(k,v) end
THREE 3
TWO 2
ONE 1
There are cross-platform functions for doing common things with paths and files
> = tmpname()
/tmp/lua_KZSFkZ
> f = tmpcpy 'hello dolly\n'
> = f
/tmp/lua_07J5r8
> readfile(f)
hello dolly
These work as expected on the other side of the fence (please note that os.tmpname()
is not safe on Windows since it doesn't prepend the temp directory!).
> = expanduser '~/.lake'
C:\Documents and Settings\SJDonova/.lake
> = tmpname()
C:\DOCUME~1\SJDonova\LOCALS~1\Temp\s3uk.
> = which 'ls'
d:\utils\bin\ls.exe
....
> = expanduser '~/.lake'
/home/steve/.lake
> = join('bonzo','dog','.txt')
bonzo/dog.txt
> = basename 'billy.boy'
billy.boy
> = extension_of 'billy.boy'
.boy
> = basename '/tmp/billy.boy'
billy.boy
> = replace_extension('billy.boy','.girl')
billy.girl
> for d in dirs '.' do print(d) end
./doc
./examples
There is a subsitution function which replaces any global variables, unless they are in an exclusion list:
> FRED = 'ok'
> = subst('$(FRED) $(DEBUG)')
ok
> return subst('$(FRED) $(DEBUG)',{DEBUG=true})
ok $(DEBUG)


Neuroplasticity is the ability of the neural networks in the brain to change through growth and reorganisation due to one’s environment by forming new neural connections over time. When learning something new, i.e coding, the brain responds by forming new neural pathways, and the more time one spends practicing that new skills, the stronger that pathway becomes. The opposite is also true, the less time one spends accessing that neural pathway, the weaker it becomes.
Understanding neuroplasticity is important as it can encourage people to learn and improve new skills that they thought they might not have been able to obtain previously because the believed they weren’t smart enough or had the capability. Because the mind is malleable This leads into the idea of having a growth mindset rather than a fixed mindset, which I will discuss shortly.
Learning about neuroplacticty is good for me as it gives me encouragement to know that learning to code is something that is very accomplishable. Even though at times it’s difficult to understand and comprehend, I need to keep practicing and strengthen my neural pathways that I’ve created.
Along with continuing to practice coding and revise the material that I’ve already learnt, there are other exercises I can do to help stimulate further nueroplasticity. Others that I might look to incorporate into my schedule are:
Coined by Carol Dweck, a growth and fixed mindset are used to describe the underlying beliefs people have about learning and intelligence. When people believe they can get smarter, they understand that effort makes them stronger. Therefore, they put in the time and effort, which ultimately, can lead to higher achievement.
A fixed mindset is the idea that knowledge and intelligence are fixed, and what you’re born with is what you have. People with this mindset are always comparing themselves with over-achievers, feeling that they need to prove themselves through their own success. Let’s take a look at the two mindsets now:
As a result, people can plateau early and achieve less than their full potential.
As a result, people can reach ever-higher levels of achievement.
With my learning, I have fallen victim to being too hard on myself when I don’t understand material or I compare myself to the success of others, making me feel like I can’t achieve something. In the past, I’ve too often had a fixed mindset, and learning about this has helped me to identify the problems that I experience.
Learning isn’t linear. It’s a road that takes many twist and turns, bumps and blocks. But you won’t get to your destination by giving up when you first get lost or come across a bump in the road. Through adopting a growth mindset, I can start to rewire the way I think and understand that through having a greater desire to learn and being persistent, I can achieve my goals and reach my destination.


|
16310
|
ED
285
1DL
|
Action Research for Teacher Leaders
See Course Catalog for Special Notes.
Only open to students in Ed.M Teacher Leadership Program.
Signature of Mr. Manuel Tuan, dept. rep., required.
Will not participate in March registration.
|
TBD
|
Open
11 /
999
/ 0
|
Applebaum, Lauren
|


--- layout: post title: "List catamorphism" description: "The catamorphism for a list is the same as its fold." date: 2019-05-27 6:10 UTC tags: [Software Design, Haskell] --- {% include JB/setup %}
{{ page.description }}
This article is part of an article series about catamorphisms. A catamorphism is a universal abstraction that describes how to digest a data structure into a potentially more compact value.
This article presents the catamorphism for (linked) lists, and other collections in general. It also shows how to identify it. The beginning of this article presents the catamorphism in C#, with an example. The rest of the article describes how to deduce the catamorphism. This part of the article presents my work in Haskell. Readers not comfortable with Haskell can just read the first part, and consider the rest of the article as an optional appendix.
The C# part of the article will discuss IEnumerable<T>
, while the Haskell part will deal specifically with linked lists. Since C# is a less strict language anyway, we have to make some concessions when we consider how concepts translate. In my experience, the functionality of IEnumerable<T>
closely mirrors that of Haskell lists.
The .NET base class library defines this Aggregate overload:
public static TAccumulate Aggregate<TSource, TAccumulate>( this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func);
This is the catamorphism for linked lists (and, I'll conjecture, for IEnumerable<T>
in general). The introductory article already used it to show several motivating examples, of which I'll only repeat the last:
> new[] { 42, 1337, 2112, 90125, 5040, 7, 1984 } . .Aggregate(Angle.Identity, (a, i) => a.Add(Angle.FromDegrees(i))) [{ Angle = 207° }]
In short, the catamorphism is, similar to the previous catamorphisms covered in this article series, a pair made from an initial value and a function. This has been true for both the Peano catamorphism and the Maybe catamorphism. An initial value is just a value in all three cases, but you may notice that the function in question becomes increasingly elaborate. For IEnumerable<T>
, it's a function that takes two values. One of the values are of the type of the input list, i.e. for IEnumerable<TSource>
it would be TSource
. By elimination you can deduce that this value must come from the input list. The other value is of the type TAccumulate
, which implies that it could be the seed
, or the result from a previous call to func
.
As in the previous article, I'll use Fix
and cata
as explained in Bartosz Milewski's excellent article on F-Algebras. The ListF
type comes from his article as well, although I've renamed the type arguments:
data ListF a c = NilF | ConsF a c deriving (Show, Eq, Read) instance Functor (ListF a) where fmap _ NilF = NilF fmap f (ConsF a c) = ConsF a $ f c
Like I did with MaybeF
, I've named the 'data' type argument a
, and the carrier type c
(for carrier). Once again, notice that the Functor
instance maps over the carrier type c
; not over the 'data' type a
.
As was also the case when deducing the Maybe catamorphism, Haskell isn't too happy about defining instances for a type like Fix (ListF a)
. To address that problem, you can introduce a newtype
wrapper:
newtype ListFix a = ListFix { unListFix :: Fix (ListF a) } deriving (Show, Eq, Read)
You can define Functor
, Applicative
, Monad
, etc. instances for this type without resorting to any funky GHC extensions. Keep in mind that ultimately, the purpose of all this code is just to figure out what the catamorphism looks like. This code isn't intended for actual use.
A few helper functions make it easier to define ListFix
values:
nilF :: ListFix a nilF = ListFix $ Fix NilF consF :: a -> ListFix a -> ListFix a consF x = ListFix . Fix . ConsF x . unListFix
With those functions, you can create ListFix
linked lists:
Prelude Fix List> nilF ListFix {unListFix = Fix NilF} Prelude Fix List> consF 42 $ consF 1337 $ consF 2112 nilF ListFix {unListFix = Fix (ConsF 42 (Fix (ConsF 1337 (Fix (ConsF 2112 (Fix NilF))))))}
The first example creates an empty list, whereas the second creates a list of three integers, corresponding to [42,1337,2112]
.
That's all you need to identify the catamorphism.
At this point, you have two out of three elements of an F-Algebra. You have an endofunctor (ListF
), and an object a
, but you still need to find a morphism ListF a c -> c
. Notice that the algebra you have to find is the function that reduces the functor to its carrier type c
, not the 'data type' a
. This takes some time to get used to, but that's how catamorphisms work. This doesn't mean, however, that you get to ignore a
, as you'll see.
As in the previous article, start by writing a function that will become the catamorphism, based on cata
:
listF = cata alg . unListFix where alg NilF = undefined alg (ConsF h t) = undefined
While this compiles, with its undefined
implementations, it obviously doesn't do anything useful. I find, however, that it helps me think. How can you return a value of the type c
from the NilF
case? You could pass an argument to the listF
function:
listF n = cata alg . unListFix where alg NilF = n alg (ConsF h t) = undefined
The ConsF
case, contrary to NilF
, contains both a head h
(of type a
) and a tail t
(of type c
). While you could make the code compile by simply returning t
, it'd be incorrect to ignore h
. In order to deal with both, you'll need a function that turns both h
and t
into a value of the type c
. You can do this by passing a function to listF
and using it:
listF :: (a -> c -> c) -> c -> ListFix a -> c listF f n = cata alg . unListFix where alg NilF = n alg (ConsF h t) = f h t
This works. Since cata
has the type Functor f => (f a -> a) -> Fix f -> a
, that means that alg
has the type f a -> a
. In the case of ListF
, the compiler infers that the alg
function has the type ListF a c -> c
, which is just what you need!
You can now see what the carrier type c
is for. It's the type that the algebra extracts, and thus the type that the catamorphism returns.
This, then, is the catamorphism for lists. As has been consistent so far, it's a pair made from an initial value and a function. Once more, this isn't the only possible catamorphism, since you can, for example, trivially flip the arguments to listF
:
listF :: c -> (a -> c -> c) -> ListFix a -> c listF n f = cata alg . unListFix where alg NilF = n alg (ConsF h t) = f h t
You can also flip the arguments of f
:
listF :: c -> (c -> a -> c) -> ListFix a -> c listF n f = cata alg . unListFix where alg NilF = n alg (ConsF h t) = f t h
These representations are all isomorphic to each other, but notice that the last variation is similar to the above C# Aggregate
overload. The initial n
value is the seed
, and the function f
has the same shape as func
. Thus, I consider it reasonable to conjecture that that Aggregate
overload is the catamorphism for IEnumerable<T>
.
You can implement most other useful functionality with listF
. The rest of this article uses the first of the variations shown above, with the type (a -> c -> c) -> c -> ListFix a -> c
. Here's the Semigroup
instance:
instance Semigroup (ListFix a) where xs <> ys = listF consF ys xs
The initial value passed to listF
is ys
, and the function to apply is simply the consF
function, thus 'consing' the two lists together. Here's an example of the operation in action:
Prelude Fix List> consF 42 $ consF 1337 nilF <> (consF 2112 $ consF 1 nilF) ListFix {unListFix = Fix (ConsF 42 (Fix (ConsF 1337 (Fix (ConsF 2112 (Fix (ConsF 1 (Fix NilF))))))))}
With a Semigroup
instance, it's trivial to also implement the Monoid
instance:
instance Monoid (ListFix a) where mempty = nilF
While you could implement mempty
with listF
(mempty = listF (const id) nilF nilF
), that'd be overcomplicated. Just because you can implement all functionality using listF
, it doesn't mean that you should, if a simpler alternative exists.
You can, on the other hand, use listF
for the Functor
instance:
instance Functor ListFix where fmap f = listF (\h l -> consF (f h) l) nilF
You could write the function you pass to listF
in a point-free fashion as consF . f
, but I thought it'd be easier to follow what happens when written as an explicit lambda expression. The function receives a 'current value' h
, as well as the part of the list which has already been translated l
. Use f
to translate h
, and consF
the result unto l
.
You can add Applicative
and Monad
instances in a similar fashion:
instance Applicative ListFix where pure x = consF x nilF fs <*> xs = listF (\f acc -> (f <$> xs) <> acc) nilF fs instance Monad ListFix where xs >>= f = listF (\x acc -> f x <> acc) nilF xs
What may be more interesting, however, is the Foldable
instance:
instance Foldable ListFix where foldr = listF
The demonstrates that listF
and foldr
is the same.
Next, you can also add a Traversable
instance:
instance Traversable ListFix where sequenceA = listF (\x acc -> consF <$> x <*> acc) (pure nilF)
Finally, you can implement conversions to and from the standard list []
type, using ana
as the dual of cata
:
toList :: ListFix a -> [a] toList = listF (:) [] fromList :: [a] -> ListFix a fromList = ListFix . ana coalg where coalg [] = NilF coalg (h:t) = ConsF h t
This demonstrates that ListFix
is isomorphic to []
, which again establishes that listF
and foldr
are equivalent.
The catamorphism for lists is a pair made from an initial value and a function. One variation is equal to foldr
. Like Maybe, the catamorphism is the same as the fold.
In C#, this function corresponds to the Aggregate
extension method identified above.
You've now seen two examples where the catamorphism coincides with the fold. You've also seen examples (Boolean catamorphism and Peano catamorphism) where there's a catamorphism, but no fold at all. In the next article, you'll see an example of a container that has both catamorphism and fold, but where the catamorphism is more general than the fold.
Next: Either catamorphism.


Failure at Tottenham could leave Jose Mourinho with the baggage of yesterday's man
The Portuguese manager brings great theatre but he is not the right fit for Tottenham
by Irishmirror.ieJose Mourinho and Tottenham doesn’t look like a match made in heaven.
And the majority view seems to be that, like his previous jobs in England, it will end in tears.
Whatever you say about the football his teams play – and he will be judged at Spurs on style as well as results – the Premier League is always a more fascinating landscape when Mourinho is at large.
Talk is cheap, and after winning 20 major trophies in his managerial career Mourinho deserves the courtesy of analysis based on facts – so here goes.
Take a look at his last 10 signings for Manchester United and judge for yourselves if they were good value:
- Lee Grant £1.5 million
- Diogo Dalot £19.8m
- Alexis Sanchez £30.6m (net value in swap deal)
- Victor Lindelof £31.5m
- Eric Bailly £34.2m
- Henrikh Mkhitaryan £37.8m
- Nemanja Matic £40.2m
- Fred £53.1m
- Romelu Lukaku £76.2m
- Paul Pogba £94.5m
That’s £419.4 million in total – of those 10 signings, how many have been a success at Old Trafford?
Hardly any – you can make a case for Lukaku being decent for one season, and maybe that Lindelof has won some people over, but even Pogba’s best moment has been winning the World Cup with France.
The fact remains, however, that since he won the Champions League with Porto in 2004, Mourinho has spent big wherever he has worked – an eye-watering £1.4 billion in total.
Look at the numbers: Porto £19.7m, Chelsea (2004-07) £334m, Inter Milan £140m, Real Madrid £168m, Chelsea (2013-15) £319m, United £419.4m.
Set that expensive spending habit against Mauricio Pochettino leading Tottenham to the Champions League final without spending a penny in two transfer windows and you can see the gap Mourinho will have to bridge at Spurs.
The bottom line, for Pochettino, is that he didn’t win a trophy in five-and-a-half years and a top-four finish this year looks highly unlikely because Tottenham have slipped 11 points beyond the dotted line after 12 games already.
I thought Pochettino did an outstanding job, changing a whole club’s mindset, overseeing the move into a £1 billion new stadium without money to spend and bringing young players like Harry Winks into first-team prominence.
Four consecutive top-four finishes is no mean feat.
And there will be a few managers, both in England and abroad, who will be feeling less secure in their jobs knowing Pochettino is out there and available.
Without jumping on the bandwagon, I just don’t see Mourinho as the right fit for Tottenham.
They are proud of their tradition for flair and expansive football at Spurs. With respect, United were laboured and shocking in the four months leading up to his exit from Old Trafford.
Yes, United finished runners-up to Manchester City in 2018 – a distant 19 points behind the champions... yet Pochettino got much closer to the title the year before, finishing seven points behind Chelsea.
Mourinho’s record as a winner speaks for itself, and you don’t win three Premier League titles at Chelsea or the Champions League with two different clubs (Porto and Inter) if you don’t know football.
But I was around the training ground at Carrington during Mourinho’s time at United, and there were people at the club who were not sorry to see the back of him.
At Tottenham, he is allegedly going to be on £88,000-a-week more than any of the players. If that is the case, Harry Kane should be going straight in to see the chairman on Monday morning to ask for a pay rise.
And younger players, like Winks and Ryan Sessegnon, are entitled to fear for their chances of regular places in the starting XI because Mourinho’s record of investing in youth is patchy at best.
Is his appointment a better bet than leaving Pochettino in place?
Only, in my opinion, if Mourinho finishes in the top four and wins a trophy.
Pochettino turned Spurs into a top-four club, so the only way Mourinho can improve on that is to keep qualifying for the Champions League and win trophies.
But Spurs are not going to win the title or the Champions League while Jurgen Klopp and Pep Guardiola are calling the tune at Liverpool and Manchester City.
Klopp and Guardiola are the special ones now – not Mourinho.
That leaves the FA Cup – somehow, Spurs managed to get knocked out of the Carabao Cup by Colchester – and if the big guns play their strongest hands, I don’t see Tottenham winning that competition, either.
So will Jose be hailed as a success if he wins the Carabao Cup?
If his appointment has the look of short-termism – win football matches now, worry about the style later – Mourinho’s best hope is to make an immediate impact.
But even there, at face value his powers of instant transformation appear to be waning. Look at his record over the first 20 league games at his previous clubs at judge for yourself.
- Porto: P20 W15 D3 L2
- Chelsea P20 W15 D4 L1
- Inter P20 W14 D4 L2
- Real Madrid P20 W16 D3 L1
- Chelsea P20 W13 D4 L3
- United P20 W11 D6 L3
And the goals are not as plentiful, either: At Real Madrid, Mourinho’s team scored 48 goals in his first 20 games, at Chelsea it was 38 and at United it was down to 31.
This has the air of Mourinho’s last stand at a big club.
Frank Lampard at Chelsea and Brendan Rodgers at Leicester are the Premier League’s most exciting shows after Liverpool and City.
As ever, Mourinho will be great theatre, always worth a listen and it’s great to have him back.
He wasn’t bigger than Real Madrid or Manchester United, but is he bigger than Tottenham? Are Spurs a bigger club now because they have landed Mourinho as their manager?
He was quick to remind the media that he has never lost a Champions League final – which is true enough. But he has lost six semi-finals.
On the night Tottenham beat his United side 3-0 at Old Trafford 15 months ago, Spurs fans were serenading Jose with the taunt: “You’re not special any more.”
We’re about to find out if that’s true. If Mourinho cannot lift Tottenham’s fortunes, he will have the baggage of yesterday’s man.


61
The Year of the LORD's Favor
1 The Spirit of the Lord GOD is upon me,
because the LORD has anointed me
to bring good news to the poor;
he has sent me to bind up the brokenhearted,
to proclaim liberty to the captives,
and the opening of the prison to those who are bound;
2 to proclaim the year of the LORD's favor,
and the day of vengeance of our God;
to comfort all who mourn;
3 to grant to those who mourn in Zion—
to give them a beautiful headdress instead of ashes,
the oil of gladness instead of mourning,
the garment of praise instead of a faint spirit;
that they may be called oaks of righteousness,
the planting of the LORD, that he may be glorified.
4 They shall build up the ancient ruins;
they shall raise up the former devastations;
they shall repair the ruined cities,
the devastations of many generations.
5 Strangers shall stand and tend your flocks;
foreigners shall be your plowmen and vinedressers;
6 but you shall be called the priests of the LORD;
they shall speak of you as the ministers of our God;
you shall eat the wealth of the nations,
and in their glory you shall boast.
7 Instead of your shame there shall be a double portion;
instead of dishonor they shall rejoice in their lot;
therefore in their land they shall possess a double portion;
they shall have everlasting joy.
8 For I the LORD love justice;
I hate robbery and wrong;
I will faithfully give them their recompense,
and I will make an everlasting covenant with them.
9 Their offspring shall be known among the nations,
and their descendants in the midst of the peoples;
all who see them shall acknowledge them,
that they are an offspring the LORD has blessed.
10 I will greatly rejoice in the LORD;
my soul shall exult in my God,
for he has clothed me with the garments of salvation;
he has covered me with the robe of righteousness,
as a bridegroom decks himself like a priest with a beautiful headdress,
and as a bride adorns herself with her jewels.
11 For as the earth brings forth its sprouts,
and as a garden causes what is sown in it to sprout up,
so the Lord GOD will cause righteousness and praise
to sprout up before all the nations.


I am Ryan Corrigan and I am a computer science major who enjoys playing sports and video games. I also enjoy other small hobbies that relate to physical activity and anything involving computers. I have a mom and dad and 2 older brothers who are both out of college. I chose to major in computer science because I have always loved computers and thought that I could do it for a living.
My favorite hobby would probably be playing table tennis with my friends. My best friend and I have been playing table tennis or commonly known as ping pong for probably half of our lives. Everytime I would go over to his house we would play and have a blast. Now that we are both in college we still find time to play ping pong with each other and the other people that we have met along the way.
I can juggle


Adding Assets, Songs, and Charts¶
/mod_assets¶
Much like modders should not touch /source, modders should also not touch /assets. Instead, modders should add mod assets under /mod_assets (obviously). The following sections will cover different folders under /mod_assets.
Folder Structure¶
Assets for any mod should be put under a folder of the same name as the mod’s class name.
For example, a .json chart for the song example-song for ExampleMod should be put under /mod_assets/data/ExampleMod/example-song/example-song.json
.
/data¶
All of a mod’s charts should be stored here.
/weeks¶
All of a mod’s song assets should be stored here.
/songs¶
All of a mod’s music files should be stored here.
/preload¶
The /preload folder contains the same structure as its parent folder, /mod_assets, but all assets under it are pre-loaded and, in-game, accessed through the root instead of /preload.
For example, an image in /mod_assets/preload/images/image.png
should be accessed in-game with /mod_assets/images/image.png
.


h2>Click the button to list your favorite things
Favorite things:
Favthings1
Favthings2
Favthings3
Favthings4
Favthings5
submit


Hi guys,
I've written some code for measuring frequency based on zero crossings. You can add the code to the EmonLib.cpp file. It basically works like this; first it searches for a zero crossing, after that it measures the time for 'x' zero crossings that passes. The 'x' is the amount of crossings you want to measure, the higher this value the more accurate it is. It searches only for positive values; by that I mean values greater than 2.5V (ADC > 512 and < 528). On the end the frequency is calculated. Here is the code to add to the EmonLib.cpp file. Make sure to adjust the EmonLib.h appropriately!
=============================================
void EnergyMonitor::calcF(int crossings)
{
boolean stf = false;
unsigned long first, second;
unsigned long delta = 0;
while(stf == false) //wait for first crossing
{
startF = analogRead(inPinV); //using the voltage waveform
if ((startF > 512) && (startF < 520))
{
stf = true; //check its within range
first = millis();
delay(4); //Make sure no second read is in this range
}
}
stf = false;
for(int i = 0 ; i < crossings ; i++)
{
while(stf == false) //wait for next crossing
{
startF = analogRead(inPinV); //using the voltage waveform
if ((startF > 512) && (startF < 528))
{
stf = true;
second = millis();
delta += (second - first); //Add time between crossings
first = second;
delay(4); //Make sure no second read is in this range
}
}
stf = false;
}
frequency = (crossings / 2) / ((double)delta / 1000);
}
=============================================
The main file looks like this:
=============================================
#include "EmonLib.h" // Include Emon Library
EnergyMonitor emon1; // Create an instance
void setup()
{
Serial.begin(38400);
emon1.voltage(4, 200.8, 0.5); // Voltage: input pin, calibration, phase_shift
void loop()
{
emon1.calcF(50); // 50 zero crossings
float freq = emon1.frequency;
Serial.print("Frequency: ");
Serial.println(freq);
delay(1000);
}
=============================================
Regards,
Mathieu
Re: Measuring frequency from the EmonLib
I have always heard that electricity can change in volt but nearly never in frequency... Thanks to your change above, do you confirm it (frequency is stable) or not?
Re: Measuring frequency from the EmonLib
Well we all know that the frequency of the power grid is 50Hz (or 60Hz). But if there is a huge change in power the frequency will change slightly dependent of the grid-constant. Yes, over time this will be corrected so that the mean frequency is always 50Hz.
What if you only have a generator as main power supply whose frequency is dependent of the load and want to measure it frequency? Well now you can measure it with my code above!
Re: Measuring frequency from the EmonLib
Martin Roberts' energy diverter has measured frequency for some time.
Just saying...
Re: Measuring frequency from the EmonLib
Yup I know and people were asking to add the code to the library. I just want to help people with this code, you are free to use it so people can make the decision for them selves what code the want to use for measuring frequency.
Re: Measuring frequency from the EmonLib
Hi Mathieu. What changes are required to be done in EmonLib.h ? Can you share with us EmonLib.cpp and EmonLib.h ?
Re: Measuring frequency from the EmonLib
Most of the changes to EmonLib.cpp are in the first post at the top of this thread. You need to add the declaration of "startF" to calcF() in EmonLib.cpp (that was missed - or it was unnecessarily included in the definition of EnergyMonitor - it can be an unsigned integer).
In EmonLib.h you need to add the definition of calcF( ) and frequency (a double) - both are public.
Note: the hard-coded constants "512", "520 and "528" should really be changed to take account of the possible use of an Arduino Due (for example) where the ADC resolution is other than 10 bits. That's already incorporated elsewhere in EmonLib so easy to implement.


License Info
Copyright 2017 Capital One Services, LLC and Bitwise,
Inc.
Licensed under the Apache License,
Version 2.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless
required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing
permissions and limitations under the License.


Israel strikes Hamas targets in Gaza after rocket fire
Unlike earlier operations, the army said the strikes did not target Islamic Jihad, but Hamas, which has de facto control over Gaza and so far has kept out of the violence that erupted this week.
Israel targeted Hamas in strikes on Gaza early Saturday after rockets were fired towards it from the Palestinian enclave, the army said, two days after a fragile ceasefire began.
Hamas, the Islamist movement that has de facto control over the Gaza Strip, has so far kept its distance from the deadly exchanges of fire that erupted this week.
A ceasefire has been in place since Thursday morning following the violent escalation between Israel and Islamic Jihad -- the territory's second most powerful Palestinian militant group.
The Israel Defence Forces (IDF) said it was "currently striking Hamas terror targets" in Gaza, where AFP journalists saw the Israeli strikes and reported retaliation from inside the enclave.
The army said it launched the strikes after "two rockets were fired from the Gaza Strip towards Israeli territory" and were intercepted by air defences.
Palestinian security sources said the Israeli strikes were aimed at two Hamas sites in the north of the territory.
It was the first time Hamas has been targeted since this week's escalation began early Tuesday with Israel's targeted killing of a top Islamic Jihad commander.
That strike triggered almost immediate retaliatory rocket fire from Islamic Jihad at Israel, setting off air-raid sirens and sending Israelis rushing to bomb shelters in the country's southern and central regions.
Fragile ceasefire
Israel's military had said around 450 rockets were fired at its territory during the fighting and air defences had intercepted dozens of them.
It then responded with its own airstrikes, saying it had targeted more Islamic Jihad militant sites and rocket- and missile-launching squads.
After two days of violence -- in which 34 Palestinians died but no Israeli fatalities -- a ceasefire was agreed.
But it has so far been precarious, with fire coming from both sides on Friday after the agreement went into effect.
The Gaza Strip is home to two million Palestinians, and Israel and Palestinian militants have fought three wars there since 2008.
Israeli analysts said earlier this week that the focus on Islamic Jihad instead of Hamas was a clear signal that the army sought to avoid a wider conflict in Gaza.
Hamas repeatedly said it would not abandon its ally, but not joining the fight helped it maintain a fragile truce with Israel that has seen tens of millions of dollars in Qatari aid flow into the impoverished Gaza Strip since last year.
On Thursday, Israeli military spokesman Jonathan Conricus told reporters that the army had "wanted to keep Hamas out of the fighting".
"Throughout the operation, we of course between distinguished Hamas and Islamic Jihad. And all of our operations were measured, proportionate and focused only on military assets belonging to Islamic jihad," he said


Aeroflot pilot dies from heart attack during flight: report
by Janine PuhakAn Aeroflot pilot reportedly died from a heart attack while piloting a domestic flight in Russia on Sunday morning. Other crew members apparently helmed an emergency landing to seek immediate medical treatment for the first officer, who was said to have passed away sometime during the descent.
The 49-year-old Aeroflot captain was piloting flight SU1546 from Moscow to Anapa when he became “ill,” prompting the Airbus 320 to land early at Platov International Airport in Rostov-on-Don, the Daily Mirror reports.
Passenger Yelena Voronova said that a flight attendant announced during the middle of the flight that a cabin crew member was not feeling well, inquiring if there were any medical professionals on board.
“A stewardess practically ran across the aisle. They later asked if there were any doctors on board and said they really needed them. Then they asked again,” Voronova said, per Russian news outlet RT.
No one came forward, as the pilot reportedly suffered a cardiac arrest, according to the Independent. The pilot is said to have died “during the landing,” in the cockpit, the Mirror reports.
Flight SU1546 departed Moscow’s Sheremetyevo Airport at 8:20 a.m. and was due to land in Anapa at 10:40 a.m., but instead touched down in Rostov around 9:57 a.m.
FOLLOW US ON FACEBOOK FOR MORE FOX LIFESTYLE NEWS
“Unfortunately it was not possible to resuscitate the pilot,” an Aeroflot spokesperson told local media, per the Mirror. The Anapa-bound flight was reportedly set to continue with a replacement pilot.
According to a source for RT, the deceased pilot had recently complained about chest pains before boarding the flight, but had passed a “routine medical check-up” and “had no health indicators that would have barred him from piloting the aircraft.”
CLICK HERE TO GET THE FOX NEWS APP
Though a spokesperson for Aeroflot, Russia's flag-carrying airline, was not immediately available to offer further comment, the Independent reports that an investigation has since been launched into the incident.


Arvind Swamy's surprise decision regarding 'Thala 60' - Tamil News - IndiaGlitz.com
Arvind Swamy made a stunning debut opposite Rajini and Mammootty in Mani Ratnam's 'Thalapathy' and ever since that has been maintaining the same fan following over the past few decades. After a self-imposed exile from Kollywood, he made a remarkable re-entry as a villain Siddharth Abhimanyu in 'Thani Oruvan' directed by Jayam Raja and starring Jayam Ravi.
Arvind Swamy was reportedly offered a major role in Ajith's upcoming movie 'Thala 60' directed by H. Vinod but has politely refused due to his commitment to 'Thalaivi' the Jayalalitha biopic in which he plays the role of MGR. Most actors want to share the screen with Thala Ajith just to experience the good-hearted charisma of the mass hero but apparently Arvind Swamy who is a good friend had to forego this time.
Trending News
Kuruthipunal connect in Gautham Menon's next!
Arvind Swamy's surprise decision regarding 'Thala 60'
Anirudh does it for Kathir's next!
"Used to have 12 tablets every day!" - Vijay's heroine reveals!
Sasikumar and Samuthirakani join hands again!
Pa Ranjith appreciates these two latest superhits!
More News
Nostalgic, mass birthday treat for Superstar Rajnikanth fans!
Thala Ajith's sweetest birthday surprise for Shalini!
Anirudh does it for Kathir's next!
"Used to have 12 tablets every day!" - Vijay's heroine reveals!
Kuruthipunal connect in Gautham Menon's next!
Siddharth joins second time with this director!
Sasikumar and Samuthirakani join hands again!
Pa Ranjith appreciates these two latest superhits!
Priyanka Chopra beats Sunny Leone
Major change in Sivakarthikeyan- Vignesh Shivan movie
Famous actress lands in trouble for wearing this dress
Top hero refuses to act in Jayalalitha biopic
Karthik Subbaraj's new movie details revealed
Tamil Nadu people will create miracle in 2021 elections: Rajinikanth
Breaking: Mohan Raja teams up with Vijay Sethupathi for the first time!
Jai spoiled Anjali - Producer's shocking allegations
"Don't question me about Rajni - Kamal!" - says TR!
Superstar Rajinikanth sways celebs and audiences at IFFI Goa
Headlines
Tamil Nadu: Woman sets daughter on fire over relationship with Dalit man
Nithyananda charged by police in child kidnapping case
Tamil Nadu: Lovers commit suicide by jumping in front of train
Chennai auto-driver murdered by five men for shocking reason
Two men arrested for posting this TikTok video
Ma Nithyananditha 's shocking allegations against her father - Video
Father electrocutes and slits daughter's throat for shocking reason
Parents of two teenaged girls file case against Nithyanandha
Will stop eating jalebis: Gautam Gambhir's outburst
Man rapes mother, sister, and sister-in-law, murdered by father


Better Bring My Meds with Me...
I was suffering from depression/combined with anxiety starting college in 2001 and after 4 years in the military. The nurse practictioner (ARPN, not MD) put me on a beginners dose of efferor xr of 37.5mg. It really sucked the first few weeks taking it, headaches, nausea, and it made me very tired in the afternoon. (I was taking my dose in the AM) Finally after a month to six weeks we arrived at my dose of 150mg a day. This stuff worked really great, if you have the insurance or cash to be maintained on it. I was on it for a year while my ins. paid for 80% cost of the meds, but when that ran out, i couldn't afford to pay $250 a month to stay on their meds.
I noticed after I had been taking effexor for a while that I damn sure better make sure I bring my meds with me. My 'doc' never told me about the importance of medication half-life, or how fast it's elimnated from the body. The active metabolite of Effexor in eliminated fairly quickly, so if I don't feel quite right before my daily fix...that's the beginning of withdrawal. Anyway, lemme just say, getting off this crap after like, a year and a half of taking it really sux. I have no idea what opiate withdrawal is like, but this has to come pretty close. DO NOT QUIT COLD-TURKEY! You could be bed-ridden for weeks. Taper your dose. If you have a really bad week and don't think you can cut down again, stick to your current cut-down dose and ride out the symptoms. Could feel sick, little energy, depressed of course, and anxious if you suffer from anxiety. And of course there's the famous head/brain shocks.
I finally switched to Prozac after about 6 months w/o effexor. It's a SSRI as opposed to effexor which is a SNRI. Anyway, prozac has one of the longest half-lives of the SS(N)RI's so if you miss a pill, no biggie. I make sure I know everything I can about a med before starting anything anymore. Know your source, know your drug, know your body.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


--- layout: post title: 'Builder Design Pattern' subtitle: 'All you need to know about the Builder Design Pattern.' date: 2019-12-11 20:45:13 +0100 categories: Software Development Design Pattern background: '/img/posts/builder-pattern/UML.png' ---
In today’s episode of Software Design Patterns you will learn everything about the Builder Design Pattern. The Builder Pattern is also pretty common and widely used. Different from the already covered behavioral pattern Observer, the Builder Pattern is a creational design patterns like Singleton and Factory Method pattern.
All the examples, source code and unit tests are in this GitHub repository.
The Gang-of-Four [1] reference book ("Design Patterns. Elements of Reusable Object-Oriented Software") describes the intent of the Builder Pattern as the following.
Separate the construction of a complex object from its representation so that the same construction process can create different representations.
Basically you have a builder and a director. In my example on GitHub I use different types of houses. There is a builder for flat and hipped houses. Those builders are created and passed to the director. The director itself constructs the different houses. To retrieve the built house the actual builder has a method for this (GetHouse()). Via this you can use the concrete house implementation.
In the picture below you find the Unified Modeling Language (UML) diagram.
In the linked GitHub repository you will find interfaces for the IHouseBuilder and the IDirector. Many resources advise you to use abstract base classes for the director and the builder - which is totally fine. I simply like interfaces more, so I went this route. The IHousebuilder interface contains the definition for building the house and retrieving the build instance. The IDirector simply has a construct method. In this method all steps should be done to build a specific thing - in our case a given type of house. The House class stores the model of a house. To make it simple I minimized the house to four property with getter only. To set value, you have to use the constructor when creating a house.
{% highlight csharp %} public interface IHouseBuilder { void BuildHouse(); House GetHouse(); } {% endhighlight %} {% highlight csharp %} public interface IDirector { void Construct(); } {% endhighlight %} {% highlight csharp %} public class House { public string PaintingColor { get; } public string RoofType { get; } public int NumbersOfFloors { get; } public bool HasCellar { get; } public House(string paintingColor, string roofType, int numbersOfFloors, bool hasCellar) { PaintingColor = paintingColor; RoofType = roofType; NumbersOfFloors = numbersOfFloors; HasCellar = hasCellar; } } {% endhighlight %}The concrete house builders sets the correspondending values when creating a new instance.
{% highlight csharp %} public class FlatRoofHouseBuilder : IHouseBuilder { private House _house = default(House); public void BuildHouse() { _house = new House("white", "flat", 1, false); } public House GetHouse() { return _house; } } {% endhighlight %} {% highlight csharp %} public class HippedRoofHouseBuilder : IHouseBuilder { private House _house = default(House); public void BuildHouse() { _house = new House("gray", "hipped", 2, true); } public House GetHouse() { return _house; } } {% endhighlight %}The construct method on the director initiates the build process for the given house builder.
{% highlight csharp %} public class HouseBuildDirector : IDirector { private readonly IHouseBuilder _houseBuilder; public HouseBuildDirector(IHouseBuilder houseBuilder) { _houseBuilder = houseBuilder; } public void Construct() { _houseBuilder.BuildHouse(); } } {% endhighlight %}In the unit tests you see the whole process of how to use the builder pattern. In this case it seems pretty odd to use such a pattern, but imagine that the complete build/construct process takes many complex steps.
{% highlight csharp %} public class BuilderPatternTest { [Fact] public void ShouldBuildFlatHouse() { var flatHouseBuilder = new FlatRoofHouseBuilder(); var houseBuildDirector = new HouseBuildDirector(flatHouseBuilder); houseBuildDirector.Construct(); var house = flatHouseBuilder.GetHouse(); house.HasCellar.Should().BeFalse(); house.PaintingColor.Should().Be("white"); house.RoofType.Should().Be("flat"); house.NumbersOfFloors.Should().Be(1); } [Fact] public void ShouldBuildHippedHouse() { var hippedRoofHouseBuilder = new HippedRoofHouseBuilder(); var houseBuildDirector = new HouseBuildDirector(hippedRoofHouseBuilder); houseBuildDirector.Construct(); var house = hippedRoofHouseBuilder.GetHouse(); house.HasCellar.Should().BeTrue(); house.PaintingColor.Should().Be("gray"); house.RoofType.Should().Be("hipped"); house.NumbersOfFloors.Should().Be(2); } }{% endhighlight %}Appendix: There are many ways of describing the builder pattern. Often it's mistaken by a fluent library where you chain different methods and eventually build an object from it. Let me know in the comments below how you find the builder or how you learned it.
In the test project you'll find test cases for subscribing, notifying and unsubscribing from observers.
If you have any questions or comments feel free to leave them below.
That’s it. Happy coding as always :).
References
[1] –Design patterns, software engineering, object-oriented programming


Configuration server connection attributes.
A part of an enclave's configuration is expected to be the same across all enclaves running under a single instance of an OS. An Enclave manager can obtain such configuration from the Asylo daemon running on the system. Alternately, the creator of the enclave manager can directly provide such configuration to the enclave manager. To this end, an EnclaveManagerOptions instance either holds the information necessary for connecting to the config server, or holds a HostConfig proto. If the enclave manager is configured with an options object containing the server-connection information, the enclave manager obtains the necessary information by contacting the Asylo daemon. Else, the enclave manager directly uses the HostConfig info stored within the options structure.
The ConfigServerConnectionAttributes struct holds information necessary for contacting the config server running inside the Asylo daemon.


Home
A small static wiki generator.
I am sure there are a lot's of static site generators (and quite a lot is in python). And, this may be just "yet another static site generator".
Actually I am not sure whether this is the case, or not.
I am designing this for personal learning. But, I have also tried to make something different.
Most of the static site generator intended for making a static blog, or maybe something like the CMS. Others that are designed for softwares' documentation, or something that can be use as a manual.
But, these are not suitable for a personal wiki.
A personal wiki -- something that is like a personal knowledge storage for some notes about things that one learn. I think, a personal wiki should be something like the wikipedia, which has tons of pages, and each page has one thing to be written down. These pages could be (should be) unorganized, unstructured. Because knowledge is meant to be free in terms of formation. All topics, all pages should be in a same level, and maybe some lists that recorded the related topics. And a very long list, maybe sorted alphabetically, as the referencing list like the encyclopedia or dictionary, for searching topics. Besides, a simple search function for looking related words from the documents and pages sea should be included too.
So, I made this Markypydia, which is designed to be the personal wiki I have just mentioned.
What is this
Markypydia is a static wiki generator, which takes the markdown wiki pages and convert it into html pages, and automatically generate the long lists as the reference list. There are two types of pages, one is for the general purpose pages, e.g. index page, about page... The other type is for the wiki documents, which is about all types of topics, which will be put inside the "wiki" directory. Markypydia will also "walk" down into each of the directories inside the wiki documents, and generate the wiki webpages for each of the wiki pages in the same directory structure. (using os.walk)
Templates and themes
I have designed or modified several theme for the use of the Markypydia, including one is modified from the orderedlist's minimal, one is build from the skeleton framework, and another is build from the milligram framework.
The theme should have three main file, document.html, list.html, and a search.html. document.html is for the wiki documents and main pages lookings; list.html is for the references list; search.html should be simple, is for the search result list.
condition of this project: under development
Well, although it looks like this could work, there are a lots of things to do before it is useable. It can now create the pages, but the links between pages is still needed to be "process". Now the links will be created automatically from the markdown.
todo
- add the function for searching the documents for internal references links, and make sure the links will find a page.
- maybe, try to automatically add reference links for those words that we have a matching documents in the wiki document sea.
- add a "not created yet" page for those words that cannot match but has been mentioned, like wikipedia.
- add a shell script function, and create the install setup.py file.
- reset the default templates folders locations.


Design
It all Begins with Design
Wherever we look, design is what provides the visual interest. From the bold and dramatic, to the soft and subdued, design creates an emotion that draws our attention.
Carin Camen Portfolio, is the fine arts arm of Camen Designs. In this setting I fully explore the fine arts to fine tune my skills that can be incorporated into my client work. Symbolism and metaphores are intertwined in my designs, bringing an emotional dimension to my work.
The Art of Design
7 Elements of Design
Elements of Design are used when creating art. They are the foundation that allows an artist to beautify their art piece. These elements can be used in combination, or by themselves. Their use surrounds us and can be found in nature, architecture and products we use on a daily basis.
Space is the area around, between or within It is either positive (white or light), or negative
(black or dark. The use of space creates the illustion of dimension and depth by placing objects
in layers of different sizes. White space provides an are around an object’s space to give the
eye rest. Dark space creates depth.
Line is fundamental in design to define edges, divide space and decorate. it is used to show
contour, gestures, expressions and to separate objects in an art piece. Line can be straight,
curved, thick or thin. Line also provides shading to create depth and shadow through small short
strokes call hatch strokes.
Color is a key element in design that creates a certain look and feel to the
art piece. Color is broken down into hue, the spectrum of a color wheel. Intensity refers to the
brightness and strength of the hue. Value is the darkness or lightness of the hue.
Value is the lightness or darkness of color. Regardless of whether an art piece
is done in black and white or color will contain value. However, value is critical in black and
white for it to succeed. The varying shades of black, grey and white allows the eye to see
dimension and form.
Form relates to objects that are three-dimensional and has length, width and
height. Form is different from shape. Shape is two dimensional. Form also provides cohesion of
the elements in how the elements unite.
Shape is two dimensional and flat. It contains only height and width. Shapes
can be organic with curves and free form. Organic shapes will have less-defined outlines. Shapes
can also be geometric with precise and defined outlines. Tools can be used to create geometric
shapes, whereas organic shapes are usually created by free hand.
Texture provides visual interest and depth. Texture can either be natural,
where it can be felt on a three dimensional object, or implied to provide the look of texture
on a two dimensional or flat surface. Texture can be created to provide a visual illusion of
what an object would feel like. The use of illusional texture provides depth on a flat surface
creating visual stimulation and appeal.
The Structure of Design
8 Principles of Design
The Principles of Design are the structural elements used in art to organize the design. These principles are applied to objects within the design. The success or failure of a design can be tied to the artist’s ability in understanding how to apply the principles of design into their artwork.
Emphasis is a focal element of a design. Emphasis directs hierarchy. When
emphasis is used, the eye is directed to the predominate part of the design and then is directed
to the supporting elements of the design. Emphasis can be used in correlation with contrast,
color and line.
Rhythm is used in harmony with pattern. It is the repetition of line, shape and color that
provides unity to the design. Rhythm also helps to organize the design and can be accomplished
in regular or irregular rhythm. Regular rhythm uses repetition in an even or slightly even pattern.
Irregular rhythm uses repetition in an uneven manner. Both provide visual interest.
Pattern is the use of repetition to provide visual stimulation and appeal.
Pattern is accomplished using line, shape and color in repetition. Pattern is achieved in
various formats that harmonize with emphais and movement.
Contrast provides visual interest and excitement in art. It refers to varying
difference in color, value, shape, size and texture. The use of light and dark, black and white
creates the strongest contrast elements in art. Having contrasting and dissimilar objects in a
design stimulates the eye and assists in creating dimension.
Balance relates to objects and how they are arranged. Balance can be symmetrical,
with both sides equal and similar. It can also be asymmetrical where both sides are different
from each other. Balance can also be used radially where the use of line and shapes draws the
eye to a focal point.
Unity allows the art of design to have a sense of completeness. All
the elements of the design work together in harmony. Unity combined with variety creates visual
visual appeal. Together, they are the finishing touches of design.
Variety draws the eye into the design to obtain more information. When there is
variety in the design, there is visual interest. If there is no variety of color, tones, hues or
objects the design will look flat.
Movement allows the viewer to journey through the design. It can show action
and motion. Using value, the eye can be directed towards a smaller part of the design that would
normally go unnoticed. Movement is a supporting element of emphasis.
Broken
Working in a monochromatic color palette, the value is an essential element. The use of line, texture and contrast are amongst the elements and principles used in this design.
This design was achieved through layering. I began with creating a background texture. Next I placed my photography photo of a silver mannequin. On top of the mannequin I played with several cracked layers. Using some photoshop techniques, I masked out part of the upper layers to make the mannequin appear as if she is breaking through what has tried to hold her back. The final touch was the tear of joy that gently falls from her cheek, she has overcome.
Past the Storm
Working with color, automatically provides visual interest. Incorporating pattern, balance, variety and space helps give this design dimension.
This design was achieved by creating the sky background using a cloud brush. Upon this layer, the grass and flowers were created. Next came the various cloud layers, causing the sun to peak out behind the white clouds to show that the sun always shines after the storm. The final touch was to create the butterfly, to indicate a renewal that occurs when we never fear facing the storms of live.
The Edge
Creating an "edgy" design is speculative of personal artistic choice. Line, texture and value is heavily used in this piece.
This piece was created by developing the foundation layer of texture. I incorporated vector images made in Illustrator into Photoshop to provide detail and visual interest. The final step was go create another layer of texture to provide the effects on and around the skull. This design symbolically represents the embracing the failure as a learning experience that will help us to succeed on a greater level. Success comes through focus, hard work and learning from failures.
Carin Camen Portfolio
Exploring Creative Possibilities
Carin Camen Portfolio is a continual exploration of design. I invite you to stop by and see my latest work.
In my fine arts portfolio, I have work showing painting, drawing, digital art and fashion. Crossing the fine arts allows me to incorporate the Elements and Principles of Design into metal for jewelry, fashion designs and painting while fully exploring these design techniques.
Copyright 2014 • Carin Camen • All Rights Reserved
carin@carincamen.com


--- layout: post esbma_id: 1584 title: Teamprise 1.0 date: 2006-04-11 18:50:09 ---
Congratulations to the folks at Teamprise, a sister company to SourceGear. They released version 1.0 of their product today. Teamprise Client Suite includes three cross-platform clients for Microsoft Team Foundation Server: an Explorer-style app, a command-line client, and an Eclipse plugin.


Is the site still up? Or is the site down?
If the site you are looking for is still down, until now, please report this error to the developers.
Can't get out of this site? Click on this hyperlink here to get redirected back.
com.error404.sitedown


Who I am
This is a quick section about me, where I'm from, what I do, blablabla...
Where I've been
Here is a quick map of the countries I've had a chance to visit.
{% include "map_visited_countries.html" %}
What I love
Cookies and photography


In this session:
You can use either Linux or Windows for this session, as well as for Sessions 2 and 3, with very minor differences. Your choice. Familiarity with Java is expected.
Lucene is a library for indexing and searching text files, written in Java and available as open source under the Apache License. It is not a standalone application; it is designed to be integrated easily into applications that have to search text in local files or from the Internet. It attempts to balance efficiency, flexibility, and conceptual simplicity at the API (Application Programming Interface) level.
Some things that Lucene does not -- so it would be the application's programmer task:
Of course, lots of people have built code that does these things on top of Lucene. In particular, we'll use a separate program called Luke to examine Lucene's indexes and to build and ask queries.
Lucene's homepage is lucene.apache.org/java/docs/index.html. Initially, Lucene was developed by Doug Cutting and was a part of Jakarta, a subproject of Apache. On february 2005, it became a top-level project within Apache.
If you work in the PC's in labs at FIB a relatively recent version should be already installed; in that case, jump to step 3 directly. Follow steps 1 and 2 if you want to install Lucene your machine.
In what follows, replace VERSION with the version numbers of the lucene and luke versions you want to install (such as 3.6.0 or 4.7.1 or 4.10.0). There was a major restructuring of the lucene code from 3.6.2 to 4.0.0; many programs for 3.x won't compile with lucene-4.x, and indices created with lucene-4.x can't be read using lucene-3.x.
Step 1: Download from http://lucene.apache.org/java/docs/index.html the compressed versions of:
and the executable of luke; normally it should be from the google code luke site, but it has not yet been updated to most recent Lucene versions of Lucene. So if you are using 4.2.x or above, get it from opengrok's web instead until it is.
Step 2: Inside lucene-VERSION.zip, locate the following .jar files:
and place them, for example, in your work directory.
Step 3: Make sure that the Java interpreter will know where to find these .jar files at runtime, adding them to the CLASSPATH.
Download these two zipped sets of files: 20_newsgroups and novels. Unzip them in your work directory, say to directories 20_newsgroups and novels. They contain respectively:
The methods in the executable demo can be called from the command window line. For example, to add all the files in the newsgroups directory to an index, just type:
java org.apache.lucene.demo.IndexFiles -docs 20_newsgroups
Try it. An index will appear in your working directory with the index files - not meant to be read by humans. You may add another flag -index indexname besides -docs to specify a directory name.
To query this index, type for instance
java org.apache.lucene.demo.SearchFiles -index index
Query: word1 word2 word3
This will return files that contain word1, word2 and word3. To make a word mandatory, add a + sign in front. The search options are described here. Besides + queries can include and -, AND, OR and NOT (in uppercase) and other connectives. For example:
Query: (word1 OR word2) AND word3
Two observations: 1) The difference between "+word" and simply "word" is that with +, word must appear in the document; without +, the word just increases the document's similarity to the query (hence its position in the ranking), though it is not strictly mandatory. 2) The NOT operator is binary and interpreted as a set difference. A query cannot start with NOT. We will understand all this better as we see the boolean and vector models in theory.
Play a bit with the searcher. Look into the groups in the corpus and try to imagine queries that would select, for example, mostly files from one particular newsgroups, or Dickens' novels and no others, etc.
After creating an index, you can use Luke to examine its contents and make queries. Click on the .jar file or type
java -jar $LUCENEDIR/lukeall-VERSION.jar -index ./index
(change to %LUCENEDIR% in Windows).
You have tabs to 1) see various statistics and word ranking 2) see info about the indexed files 3) ask queries 4) details about the index files (don't ask me...) and 5) try different analyzers (we'll discuss this concept in session 2). In the first tab, you can choose the number of top words you want to see typing the number in, then clicking on the Show top terms button.
Now index the novels corpus. Use the same line as above, but note that you can add a "-index indexnovels" option if you want to create a different index directory. Can you find a query that returns the novels by Dickens and no other? (just an example...)
Now let us look at the word distribution in these texts, and in particular whether Zipf's and Heaps' laws hold. We recommend using the novels corpus because it is much cleaner.
The CountWords.java program in the pack reads an index and writes on the standard output all the terms it contains, with their counts. (CountWords3.java is the version for lucene versions 3.x, in case you needed it). Compile it, then execute it redirecting the output to a file.
Inspect the file.  Now we are ready to analyze the data.For Zipf's law, check if the rank-frequency distribution seems to follow a power law; what are the power law parameters (f = c*(rank+b)^a) that seem to describe best what you see? We suggest using a spreadsheet and trying different triples (a,b,c) to try to imitate the number of occurrences of the word as a function of the rank. Plotting a graph (either in linear scale or in log-log scale) is also a good option. Do not depend too much on the very first (most frequent) terms, which are noisy. What matters is the long tail. Do you approximately get down to frequence 1, 2, 3, ... in the same places with your formula as the data?
Note: It is not enough to just plot the data and check that you get a decreasing curve that tends to zero. Obviously you will get such a curve. The point is: it is truly a powerlaw as these laws predict? (or an exponential? Or something else with another decrease rate?)
For Heaps' law, check if the number of distinct terms in a piece of text with N words contains about k*N^b different words for some k and beta. So: 1) create indices containing different numbers of novels, or more precisely different quantities of text, as the sizes of the novels are very different. 2) Use the little program to count the total number of words in each index, and the number of different words in each. 3) See if you find k and b that explain your results well.
To deliver: Write a short report ith your results and thoughts on the Zipf's and Heaps' tests. Explain things like: What best values of (a,b,c) and (k,b) did you find? How did you find them - what method did you use? We are less interested in long lists of words of screen prints than in your conclusions, so please 2-3 pages maximum
You are welcome to add conclusions and thoughts that depart from what we asked you to do. In fact, they'll be highly valued if they are intelligent and show that you can go beyond following instructions literally.
Procedure: Normally, use the tool in the Racó called "Practiques via web". In an emergency, send by email to "gavalda" followed by<EMAIL_ADDRESS>Deadline: Work must be delivered within 2 weeks from the lab session you attend. Late deliveries risk being penalized or not accepted at all. If you anticipate problems with the deadline, tell me as soon as possible.
Rules: 1. You can solve the problem alone or with one other person, but at most one lab assignment with the same person in the whole course. 2. No plagiarism; don't discuss your work with others, except your teammate if you are solving the problem in two; if in doubt about what is allowed, ask us. 3. If you feel you are spending much more time than the rest of the group, ask us for help. Questions can be asked either in person or by email, and you'll never be penalized by asking questions, no matter how stupid they look in retrospect.


Our Company comprises of professional & experienced team which is dedicated towards providing you secure and efficient IT services.
Sign Up for our free service to get the best by managing your assets at easy and no cost for the inital 30 days. Your experience will be valuable for us.
Our help desk service is available to assist you 24 by 7. We are there to answer your queries anytime. Simply contact us by email-phone or web.
AVT is not about making a support management system for a niche industry such as the HVAC industry, instead our aim is to make a system that empowers these companies to make their very own asset management system.
Contact our HelpDesk 24/7 at<PHONE_NUMBER> or Subscribe with Us.


{% extends "identity/base.html" %} {% block title %}Create Identity{% endblock %} {% block content %}
You can have multiple identities - they are totally separate, and share nothing apart from your login details. Use them for alternates, projects, and more.


|
This legacy installation guide shows you how to configure OSCache with Java 1.3 or in a Servlet 2.2 container (included in J2EE 1.2). The latest release may require at least Java 1.4 and/or a Servlet 2.3 container, hence you have to check the release notes and download a release which fits to your enviroment. Extraction Steps
Installation Steps
|


Custom example for Codista, for another link to grid layouts go
HERE
These Icons will scale as you resize the window


We are a multi-disciplinary club that seeks to unite students from varied backgrounds in the pursuit of design learning and excellence. Hosting both large and small events on and off campus, we work to connect current students with alumni, design professionals, and resources and prepare them to step out confidently into the working world.
Design Careers Club at UC Davis aims to empower students to take bold risks not only in their designs, but in their career aspirations. Each year, we provide three main events: Internship Night during Fall Quarter, Alumni Networking Day during Winter Quarter, and our big event, the Design Career Fair during Spring Quarter.
Whether you’re a new UCD student or a sage super-duper-senior, we’re here to help you launch your design career! We host a diverse array of workshops and events each school year to help ensure the success of UC Davis Design students — whatever that personally looks like to you! By partnering with related clubs and campus organizations we aim to demonstrate the interdisciplinary links that make design such a fantastic field and to prepare our fellow students to confidently step out into post-grad life and take the risks they need to achieve their dreams.
ALL students of ANY major are welcome at our meetings and events! Additionally if you’d like to help organize events and run the club we’re ever so excited to have you! Please contact us or show up to one of our meetings. We love collaboration and can’t wait to meet you!


One lucky bettor won $100,000 thanks to Cowboys' bizarre decision to kick a late, nearly meaningless field goal against the Patriots
by Tyler Lauletta- Dallas Cowboys head coach Jason Garrett opted for a late field goal rather than attempt to convert on fourth down late in the game against the New England Patriots.
- Garrett’s decision was frustrating for Cowboys fans but a godsend to Cowboys bettors, who needed the Cowboys to cover a 6-point spread.
- Dallas hit the field goal and went on to lose 13-9, meaning the Cowboys lost the game but covered the spread for those who had bet on the game.
- According to Darren Rovell of the Action Network, the Cowboys cover meant a $US100,000 payday for one lucky bettor.
- Visit Business Insider’s homepage for more stories.
Jason Garrett’s odd decision to kick a late field goal against the New England Patriots was met with confusion from fans but elation from Dallas Cowboys bettors.
The Cowboys trailed the Patriots 13-6 with just six minutes remaining in the fourth quarter. Dallas was driving deep into Patriots territory with a chance to tie the game with a touchdown but was facing fourth and 7 from the New England 11-yard line.
Rather than taking a shot at the first down or game-tying score,Garrett elected to kick a field goal, bringing the Cowboys within 4 points and giving the ball back to the Patriots.
For Cowboys fans, it was a frustrating, overly cautious decision from their head coach. However, to those who had bet on the Cowboys, the field goal was a godsend.
Dallas entered the game as 6-point underdogs against the Patriots, meaning that Cowboys bettors needed the team to either win or lose by less than 6 in order to cash their bets. Had Garrett gone for it on fourth down, the Cowboys would have either converted or given the ball back to the Patriots still trailing by 7.
Instead, Garrett opted to kick the field goal, meaning that Dallas still needed a touchdown to win but was now trailing 13-9, thus covering the spread for Cowboys bettors.
When Patriots took over possession, they drove into field-goal range but opted to drain the clock into its final seconds as opposed to kicking another field goal that would have once again put them past the spread. When the final whistle blew, Cowboys bettors had cashed their tickets.
According to Darren Rovell at the Action Network, Garrett’s decision led to a $US100,000 payday for one lucky bettor.
Across Twitter, other fans couldn’t believe their luck with Garrett’s decision.
Cowboys fans might not have loved Garrett’s decision to kick a field goal late, but those that bet on Dallas were laughing all the way to the bank.
- Read more:


If you see this page, then your uup-site is setup and working. You can now start publish content on your site or develop your web application. Please visit the project page for i.e. API documentation.


Emotional intelligence can be define as the intellectual or emotional ability to manage and understand one’s and other people feelings, emotions, thoughts , sensations, which allows to have a better self control and to support and help the others.
IQ is related to a different aspect of our intelligence. Is more like a way to measure the ability in different areas of knowledge, and can be measurable, in terms of productivity or ability of the person. Like “how smart u are”. EQ is related to human understanding and vision. A bit closer to “wisdom” (?)
In my opinion is not only important, is determinant in order to create a balance and healty work enviroment. Is sprint 2 I wrote about the case with my horrendous ex-workmate. That’s a classic example about how someone with extremely low EQ and a bit of a terrible personality can destroy a work environment very easy. Without EQ, the productivity of a great IQ can be limitated. EQ is the key to create a healty and enjoyable work environment.


Customer Service Rep
Hi, how can I help you today?
Customer
Hi, I’m so frustrated. You charged me extra for this month.


| Simple text field | superuser |
| Required, client-side error message | mylastname |
| Select, local array, custom display | |
| Select, remote array, no buttons | Admin |
| Select, error while loading | Active |
| Datepicker | 15/05/1984 |
| Combodate (date) | |
| Combodate (datetime) | |
| Textarea, buttons below. Submit by ctrl+enter | awesome user! |
| Twitter typeahead.js | |
| Checklist | |
| Custom input, several fields |


Find me:
Browse blogs
Techical
Blogs
Recursion
Febuary 11th, 2014
Javascript vs. Ruby
Febuary 7th, 2015
Object orientated concepts
January 29th, 2015
Ruby classes
January 17th, 2015
Enumerable methods
January 2nd, 2015
Arrays vs. Hashes
December 22nd, 2014
CSS design
December 17th, 2014
Git and Github
December 10th, 2014
Cultural
Blogs
Conflict
Febuary 14th, 2015
Values
Febuary 7th, 2015
Stereotype threat
January 29th, 2015
Feedback cycle
January 15th, 2015
Issues in the industry
January 2nd, 2015
My thinking style
Dec 25, 2014
Chefs kitchen
Dec 10, 2014
Home
-
Portfolio
-
Blogs
-
Contact
-
About
Find me:


{% if title %}
Sorry, you are unauthorised to this page!
You can either refresh this page or go back to homepage!


@*http://stackoverflow.com/questions/18619740/how-to-add-a-search-box-with-icon-to-the-navbar-in-bootstrap-3*@
Toggle navigation
Book search
Add a user
Add a book
Dashboard
Settings
Profile
Help
@*
Toggle navigation
Book Search
*@


Mark Mylod
British film and television director and producer. He is best known for his work in the HBO series Game of Thrones as a director.


clc-lisp(1) clc-lisp(1) NAME clc-clbuild - invoke lisp with clbuild active SYNOPSIS clc-lisp DESCRIPTION This is a thin wrapper round clbuild for use with common lisp controller. In effect it will just run clbuild lisp this is not working at the moment due to a patch we need to have in clbuild BUGS Bug reports should be sent to the debian BTS, preferably with reportbug. SEE ALSO AUTHOR Peter Van Eynde<EMAIL_ADDRESS>7th Edition Janurary 31, 2010 clc-lisp(1)