THE MEXICAN RATING: 6/10
For more reviews and movie wallpapers, visit http://www.joblo.com/
PLOT: A bumbling criminal has to do "one more job" before he can kiss his life in the Bad Guys Corp. goodbye. When he tells his girlfriend about his unenviable position (do or die), she tells him to take a hike, and he must then complete his mission in Mexico alone. Unfortunately, he goofs up a lot so the bad guys kidnap his now ex-girlfriend, to put more pressure on our boy to perform. Got all that?
CRITIQUE: A so-so movie that could've been a lot better if they hadn't taken such a good thing and beaten it to death. First of all, how bad can any movie starring Brad Pitt and Julia Roberts be, right? I mean, c'mon...seriously! I could watch these two planting seeds for two hours and still come out with a pretty decent-sized smile on my face. But I suppose that has more to do with their inherent good looks and zesty personalities than anything else, so obsessions aside, let me get back to the story. To be honest, I was actually quite surprised by this movie, since the trailers have been making it look like a very light, fluffy romantic comedy starring the two sweethearts of Hollywood, but the reality of the film is actually quite grimmer. In fact, the movie's stocked with profanities, contains scenes of violence and offers plenty of frank conversations about that little thing called "love", from both the hetero and homo perspectives. Basically...my kind of movie!! Hehehe. Unfortunately for the audience, the film just doesn't know when to let up and just goes on and on and on. I honestly thought that it was over two and a half hours long, but it was really only two bucks or so, I believe. What that tells me is that the film sorta "lost me" at some point around the midway mark, and even though the movie still managed to get some laughs from me here and there, it ultimately just ran out of gas (no pun intended).
In fact, the first half of the film comes out a-blazin' with a very nifty soundtrack, an infectious score, plenty of laughs via Pitt's adventures in the land of Me-hico, and some decent tete-a-tetes between Roberts and Pittski. And yeah, the directing was also top-notch. But once they split, the two stories seemed to take different emotional routes and kept me somewhat off-guard. In fact, I wasn't all that interested in the Roberts end of the story as much as Pitt's end for the most part, and didn't particularly see reason to get so much into Gandolfini's background either (we find out more about him than the two leads together!). It was as if they didn't want him to simply play this "thug" again, and they tried to develop his character somewhat, but it was all too much, for this type of movie. I would've preferred that the film stuck to its original fast-pace, hardy chuckles and fun-time chemistry. But the length of the movie and the second half's more "serious" tone, ultimately left me entertained, but not as much as I anticipated early on (one specific somber event felt particularly out of place). In fact, note to all filmmakers who decide to slap two very hot, pretty stars together for another movie in the future...uhmm, give them more scenes together, dammit!! That's what I'm paying my umpteen pesos for, buddy, I want to see Julia and Brad interact!! Granted, the story also has to be very good, but if you've got the stars to sign on the line that is dotted, why not use them in more scenes together? Just a thought.
In fact, since the film only superficially touches upon their relationship early on, you don't really feel all that much for the couple as they try to get back together throughout the movie. But all in all, the film did still manage to entertain me with its general fun vibe, its charismatic stars, its somewhat diverting story and upbeat soundtrack. Not a mucho nachos recommendation but a recommendation nonetheless.
Where's JoBlo coming from? 3,000 Miles to Graceland (7/10) - A Life Less Ordinary (5/10) - Fools Rush In (5/10) - Forces of Nature (7/10) - Payback (8/10) - True Romance (10/10) - Very Bad Things (8/10) - Way of the Gun (6/10) - The Wedding Planner (3/10) - You've Got Mail (4/10)
Review Date: February 28, 2001 Director: Gore Verbinski Writer: J.H Whyman Producers: Lawrence Bender and John Baldecchi Actors: Brad Pitt as Jerry Welbach Julia Roberts as Samantha Barzel James Gandolfini as Leroy Genre: Comedy Year of Release: 2001 ----------------------------------- JoBlo's Movie Emporium http://www.joblo.com/ ----------------------------------- (c) 2001 Berge Garabedian
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


influenza acute myocardial coronary vaccination {border-style infarction infection px;} #ffffff;} cardiovascular CI: clinical incidence patients risk prevention AMI AMI. However, association flu increased respiratory syndrome Influenza studies vaccine virus atherosclerotic causal higher measure px; secondary showed study subjects {font-family events font-size infection. inflammatory results ACS Heart Type case–control development double; evidence laboratory outcome pre-existing randomized ratio .–.). associated border-color border-width conducted different disease disease, efficacy existence heart ischaemic possible preventive published relationship significant similar solid; {font-style {font-weight Eur Furthermore, al., antibody biological bold cases causes changes compared control courier; defined did effect em; evidences including infarction. infection, infections infections, link protective pt;} role rupture specific statistical statistically strong support therefore, triggering use vaccination. year days


TradTuneDB version @version
TradTuneDb is a database of Irish, Scottish, Scandinavian and klezmer tunes. You can search for tunes and then view the scores or hear them played. Of course, having them played on a rather tinny midi piano is no substitute for hearing the real thing, but it may help you to learn the basics of a tune because you can vary the tempo. Currently, the player works with the latest releases of all the major browsers other than Internet Explorer. The best quality sound output is to be found with Chrome.
Once you have registered with TradTuneDB, you can then submit a new tune to the database. As soon as you have done this, it will be given a unique URL (which is all you have to use if you want to share it with a friend) and you will also be able to listen to your tune. Tunes are submitted in ABC notation but there are some rules to keep in mind:
- Only submit one tune at a time.
- If the tune has a name that contains non-ASCII characters (such as Polska fran Hälleforsnäs) then please use a Unicode editor to enter the name as it should naturally look and don't use the older ABC mechanism of backslashes.
- You need to supply a recognized key signature (ABC K header) and a rhythm (ABC R header) as well as a title (T). The search dropdowns will show you what values are supported.
- Try to keep the tune notation relatively simple. For example, do not indicate chords (this confuses the player). You may need to experiment with ornamentation markers because these may detract a little from the melody once it's played.
- When indicating a repeating section of a tune, balance the |: and :| markers that frame the section.
- This site is not really intended for your own compositions (unless they have started to gain traction in the session scene).
If in doubt, have a look at the ABC notation for tunes that have been submitted and play properly
Because of the one tune at a time rule, you cannot submit various variants of a tune from a single ABC file. Instead amend the titles of the variants by adding the text variant 1, variant 2 etc and submit them separately. That way, all variants will turn up in searches for the tune title.
You may find that you're disappointed with the way the tune sounds or have spotted some mistake. If so, navigate to the ABC page for the tune, delete it and then re-submit the corrected version. Or if you prefer, you can use the try it out button. This does not load the tune to the database but does show you its score. You can then edit your ABC and continue to try it out until you think the score is correct before submitting it to the database.


This is a skeleteon framework for rapid prototyping of JS components for web applications.
Take a look at the src/pages/ directory to add or change tabs, update any existing page or create new pages.
src/pages/


Safari IT Books Language Constructs Functional Programming Haskell Safari IT Books Programming Programming Programming Bryan O'Sullivan Donald Bruce Stewart John Goerzen O'Reilly Media, Inc. Real World Haskell, 1st Edition20.5. Extended Example: PipingWe've just seen how to invoke external
programs. Sometimes we need more control than that. Perhaps we need to
obtain the output from those programs, provide input, or even chain
together multiple external programs. Piping can help with all of these
needs. Piping is often used in shell scripts. When you set up a pipe in
the shell, you run multiple programs. The output of the first program is
sent to the input of the second. Its output is sent to the third as input,
and so on. The last program's output normally goes to the terminal, or it
could go to a file. Here's an example session with the POSIX shell to
illustrate piping: $ ls /etc | grep 'm.*ap' | tr a-z A-Z
IDMAPD.CONF
MAILCAP
MAILCAP.ORDER
MEDIAPRM
TERMCAP This command runs three programs, piping data between
them. It starts with ls
/etc, which outputs a list of all files or directories in
/etc. The output of ls is sent as input to grep. We gave grep a regular expression that will cause it to
output only the lines that start with 'm' and then contain "ap" somewhere in the line. Finally, the result
of that is sent to TR. We gave TR options to convert everything to uppercase.
The output of tr isn't set anywhere in
particular, so it is displayed on the screen. In this situation, the shell handles setting up all the
pipelines between programs. By using some of the POSIX tools in Haskell,
we can accomplish the same thing. Before describing how to do this, we should first warn you
that the System.Posix modules expose a
very low-level interface to Unix systems. The interfaces can be complex
and their interactions can be complex as well, regardless of the
programming language you use to access them. The full nature of these
low-level interfaces has been the topic of entire books themselves, so we
will just scratch the surface in this chapter. 20.5.1. Using Pipes for RedirectionPOSIX defines a function that creates a pipe. This function returns two file
descriptors (FDs), which are similar in concept to a Haskell Handle. One FD is the reading end of the pipe,
and the other is the writing end. Anything that is written to the
writing end can be read by the reading end. The data is "shoved through
a pipe." In Haskell, you call createPipe to access this interface. Having a pipe is the first step to being able to pipe
data between external programs. We must also be able to redirect the
output of a program to a pipe and the input of another program from a
pipe. The Haskell function dupTo
accomplishes this. It takes an FD and makes a copy of it at another FD
number. POSIX FDs for standard input, standard output, and standard
error have the predefined FD numbers of 0, 1, and 2, respectively. By
renumbering an endpoint of a pipe to one of those numbers, we
effectively can cause programs to have their input or output
redirected. There is another piece of the puzzle, however. We can't
just use dupTo before a call
such as rawSystem
because that would mess up the standard input or output of our main
Haskell process. Moreover, rawSystem
blocks until the invoked program executes, leaving us no way to start
multiple processes running in parallel. To make this happen, we must use
forkProcess. This is a very special function. It actually makes a copy
of the program currently running and we wind up with two copies of the
program running at the same time. Haskell's forkProcess function takes a function to
execute in the new process (known as the child). We have that function
call dupTo. After it has done that,
it calls executeFile to actually
invoke the command. This is also a special function: if all goes well,
it never returns. That's because executeFile
replaces the running process with a different program. Eventually, the
original Haskell process will call getProcessStatus to wait for the child processes to terminate and learn of
their exit codes. Whenever you run a command on POSIX systems, whether
you've just typed ls on the command
line or used rawSystem in Haskell,
under the hood, forkProcess, executeFile, and getProcessStatus (or their C equivalents) are
always being used. To set up pipes, we duplicate the process that the
system uses to start up programs, and add a few steps involving piping
and redirection along the way. There are a few other housekeeping things we must be
careful about. When you call forkProcess, just about everything about your
program is cloned. That includes the set of open file descriptors (handles).
Programs detect when they're done receiving input from a pipe by
checking the end-of-file indicator. When the process at the writing end
of a pipe closes the pipe, the process at the reading end will receive
an end-of-file indication. However, if the writing file descriptor
exists in more than one process, the end-of-file indicator won't be sent
until all processes have closed that particular FD. Therefore, we must
keep track of which FDs are opened so that we can close them all in the
child processes. We must also close the child ends of the pipes in the
parent process as soon as possible. Here is an initial implementation of a system of piping
in Haskell: -- file: ch20/RunProcessSimple.hs
{-# OPTIONS_GHC -fglasgow-exts #-}
-- RunProcessSimple.hs
module RunProcessSimple where
import System.Process
import Control.Concurrent
import Control.Concurrent.MVar
import System.IO
import System.Exit
import Text.Regex
import System.Posix.Process
import System.Posix.IO
import System.Posix.Types
{- | The type for running external commands. The first part
of the tuple is the program name. The list represents the
command-line parameters to pass to the command. -}
type SysCommand = (String, [String])
{- | The result of running any command -}
data CommandResult = CommandResult {
cmdOutput :: IO String, -- ^ IO action that yields the output
getExitStatus :: IO ProcessStatus -- ^ IO action that yields exit result
}
{- | The type for handling global lists of FDs to always close in the clients
-}
type CloseFDs = MVar [Fd]
{- | Class representing anything that is a runnable command -}
class CommandLike a where
{- | Given the command and a String representing input,
invokes the command. Returns a String
representing the output of the command. -}
invoke :: a -> CloseFDs -> String -> IO CommandResult
-- Support for running system commands
instance CommandLike SysCommand where
invoke (cmd, args) closefds input =
do -- Create two pipes: one to handle stdin and the other
-- to handle stdout. We do not redirect stderr in this program.
(stdinread, stdinwrite) <- createPipe
(stdoutread, stdoutwrite) <- createPipe
-- We add the parent FDs to this list because we always need
-- to close them in the clients.
addCloseFDs closefds [stdinwrite, stdoutread]
-- Now, grab the closed FDs list and fork the child.
childPID <- withMVar closefds (\fds ->
forkProcess (child fds stdinread stdoutwrite))
-- Now, on the parent, close the client-side FDs.
closeFd stdinread
closeFd stdoutwrite
-- Write the input to the command.
stdinhdl <- fdToHandle stdinwrite
forkIO $ do hPutStr stdinhdl input
hClose stdinhdl
-- Prepare to receive output from the command
stdouthdl <- fdToHandle stdoutread
-- Set up the function to call when ready to wait for the
-- child to exit.
let waitfunc =
do status <- getProcessStatus True False childPID
case status of
Nothing -> fail $ "Error: Nothing from getProcessStatus"
Just ps -> do removeCloseFDs closefds
[stdinwrite, stdoutread]
return ps
return $ CommandResult {cmdOutput = hGetContents stdouthdl,
getExitStatus = waitfunc}
-- Define what happens in the child process
where child closefds stdinread stdoutwrite =
do -- Copy our pipes over the regular stdin/stdout FDs
dupTo stdinread stdInput
dupTo stdoutwrite stdOutput
-- Now close the original pipe FDs
closeFd stdinread
closeFd stdoutwrite
-- Close all the open FDs we inherited from the parent
mapM_ (\fd -> catch (closeFd fd) (\_ -> return ())) closefds
-- Start the program
executeFile cmd True args Nothing
-- Add FDs to the list of FDs that must be closed post-fork in a child
addCloseFDs :: CloseFDs -> [Fd] -> IO ()
addCloseFDs closefds newfds =
modifyMVar_ closefds (\oldfds -> return $ oldfds ++ newfds)
-- Remove FDs from the list
removeCloseFDs :: CloseFDs -> [Fd] -> IO ()
removeCloseFDs closefds removethem =
modifyMVar_ closefds (\fdlist -> return $ procfdlist fdlist removethem)
where
procfdlist fdlist [] = fdlist
procfdlist fdlist (x:xs) = procfdlist (removefd fdlist x) xs
-- We want to remove only the first occurance ot any given fd
removefd [] _ = []
removefd (x:xs) fd
| fd == x = xs
| otherwise = x : removefd xs fd
{- | Type representing a pipe. A 'PipeCommand' consists of a source
and destination part, both of which must be instances of
'CommandLike'. -}
data (CommandLike src, CommandLike dest) =>
PipeCommand src dest = PipeCommand src dest
{- | A convenient function for creating a 'PipeCommand'. -}
(-|-) :: (CommandLike a, CommandLike b) => a -> b -> PipeCommand a b
(-|-) = PipeCommand
{- | Make 'PipeCommand' runnable as a command -}
instance (CommandLike a, CommandLike b) =>
CommandLike (PipeCommand a b) where
invoke (PipeCommand src dest) closefds input =
do res1 <- invoke src closefds input
output1 <- cmdOutput res1
res2 <- invoke dest closefds output1
return $ CommandResult (cmdOutput res2) (getEC res1 res2)
{- | Given two 'CommandResult' items, evaluate the exit codes for
both and then return a "combined" exit code. This will be ExitSuccess
if both exited successfully. Otherwise, it will reflect the first
error encountered. -}
getEC :: CommandResult -> CommandResult -> IO ProcessStatus
getEC src dest =
do sec <- getExitStatus src
dec <- getExitStatus dest
case sec of
Exited ExitSuccess -> return dec
x -> return x
{- | Execute a 'CommandLike'. -}
runIO :: CommandLike a => a -> IO ()
runIO cmd =
do -- Initialize our closefds list
closefds <- newMVar []
-- Invoke the command
res <- invoke cmd closefds []
-- Process its output
output <- cmdOutput res
putStr output
-- Wait for termination and get exit status
ec <- getExitStatus res
case ec of
Exited ExitSuccess -> return ()
x -> fail $ "Exited: " ++ show x
Let's experiment with this in ghci a bit before looking at how it
works: ghci> :load RunProcessSimple.hs
[1 of 1] Compiling RunProcessSimple ( RunProcessSimple.hs, interpreted )
Ok, modules loaded: RunProcessSimple.
ghci> runIO $ ("pwd", []::[String])
Loading package array-<IP_ADDRESS> ... linking ... done.
Loading package bytestring-<IP_ADDRESS>.1 ... linking ... done.
Loading package old-locale-<IP_ADDRESS> ... linking ... done.
Loading package old-time-<IP_ADDRESS> ... linking ... done.
Loading package filepath-<IP_ADDRESS> ... linking ... done.
Loading package directory-<IP_ADDRESS> ... linking ... done.
Loading package unix-<IP_ADDRESS> ... linking ... done.
Loading package process-<IP_ADDRESS> ... linking ... done.
Loading package regex-base-<IP_ADDRESS> ... linking ... done.
Loading package regex-posix-<IP_ADDRESS> ... linking ... done.
Loading package regex-compat-<IP_ADDRESS> ... linking ... done.
/home/bos/src/darcs/book/examples/ch20
ghci> runIO $ ("ls", ["/usr"])
bin
etc
games
include
java
kerberos
lib
lib64
libexec
local
sbin
share
src
tmp
X11R6
ghci> runIO $ ("ls", ["/usr"]) -|- ("grep", ["^l"])
lib
lib64
libexec
local
ghci> runIO $ ("ls", ["/etc"]) -|- ("grep", ["m.*ap"]) -|- ("tr", ["a-z", "A-Z"])
IDMAPD.CONF
MAILCAP
PM-UTILS-HD-APM-RESTORE.CONF We start by running a simple command, pwd, which just prints the name of the current working directory. We
pass [] for the list of arguments,
because pwd doesn't need any
arguments. Due to the typeclasses used, Haskell can't infer the type of
[], so we specifically mention that
it's a String. Then we get into more complex commands. We run ls, sending it through grep. At the end, we set up a pipe to run the
exact same command that we ran via a shell-built pipe at the start of
this section. It's not yet as pleasant as it was in the shell, but then
again our program is still relatively simple when compared to the
shell. Let's look at the program. The very first line has a
special OPTIONS_GHC clause. This is the same as passing -fglasgow-exts to ghc or ghci. We are using a GHC extension that
permits us to use a (String,
[String]) type as an instance of a typeclass. Putting it in the source file means we don't have to
remember to specify it every time we use this module. After the import
lines, we define a few types. First, we define type SysCommand = (String, [String]) as an
alias. This is the type a command to be executed by the system will
take. We used data of this type for each command in the example
execution above. The CommandResult
type represents the result from executing a given command, and the
CloseFDs type represents the list of
FDs that we must close upon forking a new child process. Next, we define a class named CommandLike, which will be used to run
"things," where a "thing" might be a standalone program, a pipe set up
between two or more programs, or in the future, even pure Haskell
functions. To be a member of this class, only one function—invoke—needs to be present for a given type.
This will let us use runIO to start
either a standalone command or a pipeline. It will also be useful for
defining a pipeline, since we may have a whole stack of commands on one
or both sides of a given command. Our piping infrastructure is going to use strings as the
way of sending data from one process to another. We can take advantage
of Haskell's support for lazy reading via hGetContents while reading data, and use
forkIO to let writing occur in the
background. This will work well, although not as fast as connecting the
endpoints of two processes directly together. It makes implementation quite simple, however. We need
only take care to do nothing that would require the entire String to be buffered, and let Haskell's
laziness do the rest. Next, we define an instance of CommandLike for SysCommand. We create two pipes: one to use
for the new process's standard input, and the other for its standard
output. This creates four endpoints, and thus four file descriptors. We
add the parent file descriptors to the list of those that must be closed
in all children. These would be the write end of the child's standard
input, and the read end of the child's standard output. Next, we fork
the child process. In the parent, we can then close the file descriptors
that correspond to the child. We can't do that before the fork, because
they wouldn't be available to the child. We obtain a handle for the
stdinwrite file descriptor, and start
a thread via forkIO to write the
input data to it. We then define waitfunc, which is the action that the caller
will invoke when it is ready to wait for the called process to
terminate. Meanwhile, the child uses dupTo, closes the file descriptors it doesn't
need, and executes the command. Next, we define some utility functions to manage the
list of file descriptors. After that, we define the tools that help set
up pipelines. First, we define a new type PipeCommand that has a source and destination.
Both the source and destination must be members of CommandLike. We also define the -|- convenience operator. Then, we make
PipeCommand an
instance of CommandLike. Its invoke implementation starts the first command
with the given input, obtains its output, and passes that output to the
invocation of the second command. It then returns the output of the
second command and causes the getExitStatus function to wait for and check
the exit statuses from both commands. We finish by defining runIO. This function establishes the list of
FDs that must be closed in the client, starts the command, displays its
output, and checks its exit status. 20.5.2. Better PipingOur previous example solved the basic need of letting us
set up shell-like pipes. There are some other features that it would be
nice to have though: Support more shell-like syntax The ability to let people pipe data into external
programs or regular Haskell functions, freely mixing and matching
the two The ability to return the final output and exit code
in a way that Haskell programs can readily use
Fortunately, we already have most of the pieces to
support this in place. We need only to add a few more instances of
CommandLike to support this and a few
more functions similar to runIO. Here
is a revised example that implements all of these features: -- file: ch20/RunProcess.hs
{-# OPTIONS_GHC -fglasgow-exts #-}
module RunProcess where
import System.Process
import Control.Concurrent
import Control.Concurrent.MVar
import Control.Exception(evaluate)
import System.Posix.Directory
import System.Directory(setCurrentDirectory)
import System.IO
import System.Exit
import Text.Regex
import System.Posix.Process
import System.Posix.IO
import System.Posix.Types
import Data.List
import System.Posix.Env(getEnv)
{- | The type for running external commands. The first part
of the tuple is the program name. The list represents the
command-line parameters to pass to the command. -}
type SysCommand = (String, [String])
{- | The result of running any command -}
data CommandResult = CommandResult {
cmdOutput :: IO String, -- ^ IO action that yields the output
getExitStatus :: IO ProcessStatus -- ^ IO action that yields exit result
}
{- | The type for handling global lists of FDs to always close in the clients
-}
type CloseFDs = MVar [Fd]
{- | Class representing anything that is a runnable command -}
class CommandLike a where
{- | Given the command and a String representing input,
invokes the command. Returns a String
representing the output of the command. -}
invoke :: a -> CloseFDs -> String -> IO CommandResult
-- Support for running system commands
instance CommandLike SysCommand where
invoke (cmd, args) closefds input =
do -- Create two pipes: one to handle stdin and the other
-- to handle stdout. We do not redirect stderr in this program.
(stdinread, stdinwrite) <- createPipe
(stdoutread, stdoutwrite) <- createPipe
-- We add the parent FDs to this list because we always need
-- to close them in the clients.
addCloseFDs closefds [stdinwrite, stdoutread]
-- Now, grab the closed FDs list and fork the child.
childPID <- withMVar closefds (\fds ->
forkProcess (child fds stdinread stdoutwrite))
-- Now, on the parent, close the client-side FDs.
closeFd stdinread
closeFd stdoutwrite
-- Write the input to the command.
stdinhdl <- fdToHandle stdinwrite
forkIO $ do hPutStr stdinhdl input
hClose stdinhdl
-- Prepare to receive output from the command
stdouthdl <- fdToHandle stdoutread
-- Set up the function to call when ready to wait for the
-- child to exit.
let waitfunc =
do status <- getProcessStatus True False childPID
case status of
Nothing -> fail $ "Error: Nothing from getProcessStatus"
Just ps -> do removeCloseFDs closefds
[stdinwrite, stdoutread]
return ps
return $ CommandResult {cmdOutput = hGetContents stdouthdl,
getExitStatus = waitfunc}
-- Define what happens in the child process
where child closefds stdinread stdoutwrite =
do -- Copy our pipes over the regular stdin/stdout FDs
dupTo stdinread stdInput
dupTo stdoutwrite stdOutput
-- Now close the original pipe FDs
closeFd stdinread
closeFd stdoutwrite
-- Close all the open FDs we inherited from the parent
mapM_ (\fd -> catch (closeFd fd) (\_ -> return ())) closefds
-- Start the program
executeFile cmd True args Nothing
{- | An instance of 'CommandLike' for an external command. The String is
passed to a shell for evaluation and invocation. -}
instance CommandLike String where
invoke cmd closefds input =
do -- Use the shell given by the environment variable SHELL,
-- if any. Otherwise, use /bin/sh
esh <- getEnv "SHELL"
let sh = case esh of
Nothing -> "/bin/sh"
Just x -> x
invoke (sh, ["-c", cmd]) closefds input
-- Add FDs to the list of FDs that must be closed post-fork in a child
addCloseFDs :: CloseFDs -> [Fd] -> IO ()
addCloseFDs closefds newfds =
modifyMVar_ closefds (\oldfds -> return $ oldfds ++ newfds)
-- Remove FDs from the list
removeCloseFDs :: CloseFDs -> [Fd] -> IO ()
removeCloseFDs closefds removethem =
modifyMVar_ closefds (\fdlist -> return $ procfdlist fdlist removethem)
where
procfdlist fdlist [] = fdlist
procfdlist fdlist (x:xs) = procfdlist (removefd fdlist x) xs
-- We want to remove only the first occurance ot any given fd
removefd [] _ = []
removefd (x:xs) fd
| fd == x = xs
| otherwise = x : removefd xs fd
-- Support for running Haskell commands
instance CommandLike (String -> IO String) where
invoke func _ input =
return $ CommandResult (func input) (return (Exited ExitSuccess))
-- Support pure Haskell functions by wrapping them in IO
instance CommandLike (String -> String) where
invoke func = invoke iofunc
where iofunc :: String -> IO String
iofunc = return . func
-- It's also useful to operate on lines. Define support for line-based
-- functions both within and without the IO monad.
instance CommandLike ([String] -> IO [String]) where
invoke func _ input =
return $ CommandResult linedfunc (return (Exited ExitSuccess))
where linedfunc = func (lines input) >>= (return . unlines)
instance CommandLike ([String] -> [String]) where
invoke func = invoke (unlines . func . lines)
{- | Type representing a pipe. A 'PipeCommand' consists of a source
and destination part, both of which must be instances of
'CommandLike'. -}
data (CommandLike src, CommandLike dest) =>
PipeCommand src dest = PipeCommand src dest
{- | A convenient function for creating a 'PipeCommand'. -}
(-|-) :: (CommandLike a, CommandLike b) => a -> b -> PipeCommand a b
(-|-) = PipeCommand
{- | Make 'PipeCommand' runnable as a command -}
instance (CommandLike a, CommandLike b) =>
CommandLike (PipeCommand a b) where
invoke (PipeCommand src dest) closefds input =
do res1 <- invoke src closefds input
output1 <- cmdOutput res1
res2 <- invoke dest closefds output1
return $ CommandResult (cmdOutput res2) (getEC res1 res2)
{- | Given two 'CommandResult' items, evaluate the exit codes for
both and then return a "combined" exit code. This will be ExitSuccess
if both exited successfully. Otherwise, it will reflect the first
error encountered. -}
getEC :: CommandResult -> CommandResult -> IO ProcessStatus
getEC src dest =
do sec <- getExitStatus src
dec <- getExitStatus dest
case sec of
Exited ExitSuccess -> return dec
x -> return x
{- | Different ways to get data from 'run'.
* IO () runs, throws an exception on error, and sends stdout to stdout.
* IO String runs, throws an exception on error, reads stdout into
a buffer, and returns it as a string.
* IO [String] is same as IO String, but returns the results as lines.
* IO ProcessStatus runs and returns a ProcessStatus with the exit
information. stdout is sent to stdout. Exceptions are not thrown.
* IO (String, ProcessStatus) is like IO ProcessStatus, but also
includes a description of the last command in the pipe to have
an error (or the last command, if there was no error).
* IO Int returns the exit code from a program directly. If a signal
caused the command to be reaped, returns 128 + SIGNUM.
* IO Bool returns True if the program exited normally (exit code 0,
not stopped by a signal) and False otherwise.
-}
class RunResult a where
{- | Runs a command (or pipe of commands), with results presented
in any number of different ways. -}
run :: (CommandLike b) => b -> a
-- | Utility function for use by 'RunResult' instances
setUpCommand :: CommandLike a => a -> IO CommandResult
setUpCommand cmd =
do -- Initialize our closefds list
closefds <- newMVar []
-- Invoke the command
invoke cmd closefds []
instance RunResult (IO ()) where
run cmd = run cmd >>= checkResult
instance RunResult (IO ProcessStatus) where
run cmd =
do res <- setUpCommand cmd
-- Process its output
output <- cmdOutput res
putStr output
getExitStatus res
instance RunResult (IO Int) where
run cmd = do rc <- run cmd
case rc of
Exited (ExitSuccess) -> return 0
Exited (ExitFailure x) -> return x
Terminated x -> return (128 + (fromIntegral x))
Stopped x -> return (128 + (fromIntegral x))
instance RunResult (IO Bool) where
run cmd = do rc <- run cmd
return ((rc::Int) == 0)
instance RunResult (IO [String]) where
run cmd = do r <- run cmd
return (lines r)
instance RunResult (IO String) where
run cmd =
do res <- setUpCommand cmd
output <- cmdOutput res
-- Force output to be buffered
evaluate (length output)
ec <- getExitStatus res
checkResult ec
return output
checkResult :: ProcessStatus -> IO ()
checkResult ps =
case ps of
Exited (ExitSuccess) -> return ()
x -> fail (show x)
{- | A convenience function. Refers only to the version of 'run'
that returns @IO<EMAIL_ADDRESS>This prevents you from having to cast to it
all the time when you do not care about the result of 'run'.
-}
runIO :: CommandLike a => a -> IO ()
runIO = run
------------------------------------------------------------
-- Utility Functions
------------------------------------------------------------
cd :: FilePath -> IO ()
cd = setCurrentDirectory
{- | Takes a string and sends it on as standard output.
The input to this function is never read. -}
echo :: String -> String -> String
echo inp _ = inp
-- | Search for the regexp in the lines. Return those that match.
grep :: String -> [String] -> [String]
grep pat = filter (ismatch regex)
where regex = mkRegex pat
ismatch r inp = case matchRegex r inp of
Nothing -> False
Just _ -> True
{- | Creates the given directory. A value of 0o755 for mode would be typical.
An alias for System.Posix.Directory.createDirectory. -}
mkdir :: FilePath -> FileMode -> IO ()
mkdir = createDirectory
{- | Remove duplicate lines from a file (like Unix uniq).
Takes a String representing a file or output and plugs it through
lines and then nub to uniqify on a line basis. -}
uniq :: String -> String
uniq = unlines . nub . lines
-- | Count number of lines. wc -l
wcL, wcW :: [String] -> [String]
wcL inp = [show (genericLength inp :: Integer)]
-- | Count number of words in a file (like wc -w)
wcW inp = [show ((genericLength $ words $ unlines inp) :: Integer)]
sortLines :: [String] -> [String]
sortLines = sort
-- | Count the lines in the input
countLines :: String -> IO String
countLines = return . (++) "\n" . show . length . lines
Here's what has changed: A new CommandLike
instance for String that uses the
shell to evaluate and invoke the string. New CommandLike
instances for String -> IO
String and various other types that are implemented in
terms of this one. These process Haskell functions as commands. A new RunResult
typeclass that defines a function run that returns information about the
command in many different ways. See the comments in the source for
more information. runIO is now
just an alias for one particular RunResult instance. A few utility functions providing Haskell
implementations of familiar Unix shell commands.
Let's try out the new shell features. First, let's make
sure that the command we used in the previous example still works. Then,
let's try it using a more shell-like syntax. ghci> :load RunProcess.hs
[1 of 1] Compiling RunProcess ( RunProcess.hs, interpreted )
Ok, modules loaded: RunProcess.
ghci> runIO $ ("ls", ["/etc"]) -|- ("grep", ["m.*ap"]) -|- ("tr", ["a-z", "A-Z"])
Loading package array-<IP_ADDRESS> ... linking ... done.
Loading package bytestring-<IP_ADDRESS>.1 ... linking ... done.
Loading package old-locale-<IP_ADDRESS> ... linking ... done.
Loading package old-time-<IP_ADDRESS> ... linking ... done.
Loading package filepath-<IP_ADDRESS> ... linking ... done.
Loading package directory-<IP_ADDRESS> ... linking ... done.
Loading package unix-<IP_ADDRESS> ... linking ... done.
Loading package process-<IP_ADDRESS> ... linking ... done.
Loading package regex-base-<IP_ADDRESS> ... linking ... done.
Loading package regex-posix-<IP_ADDRESS> ... linking ... done.
Loading package regex-compat-<IP_ADDRESS> ... linking ... done.
IDMAPD.CONF
MAILCAP
PM-UTILS-HD-APM-RESTORE.CONF
ghci> runIO $ "ls /etc" -|- "grep 'm.*ap'" -|- "tr a-z A-Z"
IDMAPD.CONF
MAILCAP
PM-UTILS-HD-APM-RESTORE.CONF That was a lot easier to type. Let's try substituting
our native Haskell implementation of grep and try out some other new features as
well: ghci> runIO $ "ls /etc" -|- grep "m.*ap" -|- "tr a-z A-Z"
IDMAPD.CONF
MAILCAP
PM-UTILS-HD-APM-RESTORE.CONF
ghci> run $ "ls /etc" -|- grep "m.*ap" -|- "tr a-z A-Z" :: IO String
"IDMAPD.CONF\nMAILCAP\nPM-UTILS-HD-APM-RESTORE.CONF\n"
ghci> run $ "ls /etc" -|- grep "m.*ap" -|- "tr a-z A-Z" :: IO [String]
["IDMAPD.CONF","MAILCAP","PM-UTILS-HD-APM-RESTORE.CONF"]
ghci> run $ "ls /nonexistant" :: IO String
ls: cannot access /nonexistant: No such file or directory
*** Exception: user error (Exited (ExitFailure 2))
ghci> run $ "ls /nonexistant" :: IO ProcessStatus
ls: cannot access /nonexistant: No such file or directory
Exited (ExitFailure 2)
ghci> run $ "ls /nonexistant" :: IO Int
ls: cannot access /nonexistant: No such file or directory
2
ghci> runIO $ echo "Line1\nHi, test\n" -|- "tr a-z A-Z" -|- sortLines
HI, TEST
LINE1 20.5.3. Final Words on PipesWe have developed a sophisticated system here. We warned
you earlier that POSIX can be complex. One other thing we need to
highlight: you must always make sure to evaluate the String returned by these functions before you
attempt to evaluate the exit code of the child process. The child
process will often not exit until it can write all of its data, and if
you do this in the wrong order, your program will hang. In this chapter, we developed, from the ground up, a
simplified version of HSH. If you wish to use these shell-like
capabilities in your own programs, we recommend HSH instead of the
example developed here due to optimizations present in HSH. HSH also
comes with a larger set of utility functions and more capabilities, but
the source code behind the library is much more complex and large. Some
of the utility functions presented here, in fact, were copied verbatim
from HSH. HSH is available at
.
|


Explainable Reasoning in Face of Contradictions: From Humans to Machines
Dov Gabbay
Paper: Kampik & Gabbay. Explainable Reasoning in Face of Contradictions: From Humans to Machines.
#### Outline
* We claim that a key characteristic of intelligent behavior is the ability to make and **explain** decisions in the face of contradictions.
* We motivate this claim by looking at research in micro-economic theory and behavioral economics.
* We outline a set of future research directions.
What is (Artificial) Intelligence?
What is (Artificial) Intelligence?
#### Example: British Nationality Program
* 1980: $\Delta$
* Query from $\Delta$: can ${\cal A}$ get British passport?
* Program: **Prolog**
#### $\Delta$: can ${\cal A}$ get British passport?
* Answer: no
Explanation: trace of attempted proof with output of what is missing
* (1) $a \rightarrow b$
* (2) $a
* $?_{(1), (2)} b = $ yes, from (1), (2)
* $?_{(1)} b = $ no, (2) is needed
#### Choice (Gabbay example)
* Test for cancer inconclusive
* ${\cal H}$ is consistent to assume ${\cal A}$ has cancer
* ${\cal H}$ is consistent to assume ${\cal A}$ does not have cancer
* Program: **Logica**
Tretyakov and Skvortsov (Google). *Logica Open Source Project*. 2021.
#### What happens if data is inconsistent?
* All queries can be answered with `yes`.
* We need priorities.
Human reason according to prioritiess
Human Reasoning has been studied for centuries
How should we make decisions?
How should we treat doubt?
Example: the Talmud and Shev Shema'tata.
Line from religious to legal reasoning
Line from religious reasoning to economic theory?
#### Economic Rationality
* Assumptions of economic rationality, **ceteris paribus** (if everything else equal):
* "Rational Economic Man" acts according to clear preferences
* Has consistent preferences over time
#### Clear Preferences
* Standard economic model for individual decision-making
* Chooses from $A = \\{a, ..., n\\}$
* Choice function: takes $A$, returns $S^* \in 2^A$
* Clear preferences: choice $S^\*$ implies $S^*$ is strictly preferred over all other elements in $2^A$
Rubinstein, Ariel. *Modeling bounded rationality.*
Clear Preferences
$a$: ${\cal A}$ has cancer, $b$: ${\cal A}$ does not have cancer
#### Consistent Preferences (Reference Independence)
* Set of choice options $A, A'$, such that $A \subseteq A'$
* Rational man's choices $A^{\*} \subseteq A$ and $A'^{\*} \subseteq A'$
* If $A'^{\*} \subseteq A$ then $A^{\*} = A'^{\*}$
Rubinstein, Ariel. *Modeling bounded rationality.*
#### Example
* We go to a café, on the menu: `tea and coffee`
* We choose `coffee`
* Next day, one the menu: `tea, coffee, and cookie`
We choose `tea and cookie`. Are we rational?
We choose `tea`. Are we rational?
Bounded Rationality
By now, we know that economic rationality is not a good model of human (intelligent) decision-making.
Lacks a model of knowledge.
Economists try to adjusts their models accordingly.
With formal argumentation, we can draw inferences in face of contradictions that are economically rational.
Kahneman, Daniel. *Modeling bounded rationality.*
Rubinstein, Ariel. *Modeling bounded rationality.*
#### What does this have to do with Explainable Agents?
"Reasoning Backwards"
We also know that humans "reason backwards".
We commit to a decision intuitively.
We make up a line of reasoning if necessary.
Haidt, Jonathan. *The emotional dog and its rational tail: a social intuitionist approach to moral judgment.*
#### What does this have to do with contradiction resolution?
#### → Stages of Reasoning/Decision-Making Capabilities
1. Clear preferences: Ability to make a decision no matter what
2. Consistent preferences: Implied by Decision
Considering knowledge or justified beliefs about the world
3.  What has changed?*
* **Mourinho**: [*That was*] *before I was sacked* [*at Chelsea*].
* After recent events, Mourinho may say want to revert to the original statement
4. Principle-based & Evidence-based reasoning
Let us look into this!
#### An Argumentation Perspective
#### Economic Rationality & Abstract Argumentation
* $AF = (AR, AT)$; arguments $AR$, e.g.: $\\{a, b, c\\}$, attacks $AT$, e.g.: $\\{(a, b), (b, c)\\}$
* Semantics $\sigma(AF)$ returns set of extensions $ES \subseteq 2^{AR}$
#### Normal Expansion
* Given $AF = (AR, AT), AF' = (AR', AT')$ AF' normally expands AF iff:
* $AR \subseteq AR', AT \subseteq AT'$
* $(AT' \setminus AT) \cap (AR \times AR) = \\{\\}$
* Only add arguments and attacks, don't change attacks between existing arguments
* Denoted by $AF \preceq_N AF'$ (Baumann, Brewka)
#### Clear Preferences
* Semantics that are universally defined, or extension-selection "on top of" semantics
* Example of absence of clear preferences: Stable semantics, $AF = (\\{a\\}, \\{(a, a)\\})$
#### Clear Preferences
* Q: Is uniqueness required?
* Answer: not necessarily, because we know how to break ties
#### Consistent Preferences
* Argumentation framework $AF = (AR, AT)$
* Semantics $\sigma$, extensions $ES = \sigma(AF)$
* Conclusion $E \in ES, E \subseteq AR$ **implies** preferences: $\forall S \in AR, E \succeq S$
* Consistent preferences when **normally expanding** $AF$ (Economics' *ceteris paribus* assumption)
(In)consistent Preferences
$\{a\} \succeq \{\}$
$\{\} \succeq \{a\}$
#### Reasoning Backwards
* Finding arguments that fit the conclusion
* Searching for a line of reasoning that happens to suite the narrative
(a formal principle that happens to be satisfied)
Reasoning Backwards
$\{a\} \succeq \{b\}$
$\{b\} \succeq \{a\}$
Reasoning Backwards
#### Principle-based / Evidence-based Reasoning
* Construct an argumentation framework, one argument at a time
* Check principle satisfaction, one argument at a time
* Focus on the **effect of change** to a base of contradicting beliefs on the conclusions that are inferred
* Apply a cross-disciplinary perspective on human reasoning and decision-making
#### Research Directions
#### Automated Reasoning and (Bounded) Economic Rationality
* How can we apply principles of (boundedly) rational decision-making to automated (non)-monotonic reasoning?
* How should we relax these principles?
Kampik & Gabbay. *Towards DiArg - An Argumentation-based Dialogue Reasoner*.
Kampik & Nieves. *Abstract Argumentation and the Rational Man*.
#### Automated Reasoning and Intuitive Rationality
* What principles find humans intuitive?
* Are these principles generally applicable, or are there domain-specific or population-specific differences?
Cramer & Guillaume. *Empirical cognitive study on abstract argumentation semantics*.
Cramer & Guillaume. *Empirical study on human evaluation of complex argumentation frameworks*.
#### Principle-based Semantics Design
* Well-established, long-running research direction
* New/emerging: focus on relational properties:
* What happens when **adding a new argument**/attack?
* What happens when "forgetting" an argument/attack?
#### Principle-based Semantics Design
Van der Torre & Vesic. *The principle-based approach to abstract argumentation semantics*.
Baroni & Giacomin. *On principle-based evaluation of extension-based argumentation semantics*.
Bauman & Brewka. *Expanding Argumentation Frameworks: Enforcing and Monotonicity Results*.
Rienstra, Sakam & Van der Torre. *Persistence and Monotony Properties of Argumentation Semantics*.
Kampik & Nieves. *Abstract Argumentation and the Rational Man*.
#### Burden of Proof/Persuasion
* Legal theory: in case of a conflict, place the "burden of persuasion" on one of the parties
* Relates to centuries of research on how to resolve logical contradictions
* Can we create an abstract framework for managing the burden of persuasion?
Calegari & Sartor. *A model for the burden of persuasion in argumentation*.
Prakken & Sartor. *A Logical Analysis of Burdens of Proof*.
Abraham, Gabbay & Schild. *The Handling of Loops in Talmudic Logic*.
#### Integration with Machine Learning
* More and more works integrate symbolic reasoning and machine learning
* We can learn formal models that satisfy reasoning principles (like monotony properties)
* What practical guarantees can we get from these principles?
* How can we learn principles?
Example: Learning Principles
Example: Learning Principles
Positive reward
Negative reward
#### Example: Learning Principles
* Current conclusion is principle-compliant but yields negative reward
* Can we tighten or a relax the principle in a way that gives us better rewards?
* What about the principle "if in doubt, remain consistent"
* We can formalize it, but can we learn it?
Questions?
Special Issue in the Journal of Applied Logics - IfCoLog Journal:
*Explainable Reasoning in Face of Contradictions: Cross-disciplinary Perspectives*
[Link to the paper](https://people.cs.umu.se/tkampik/reports/Kampik_Gabbay_reasoning_contradictions.pdf)


In my spare time I code!
Just a few things I enjoy doing
You can reach me at hollmanc at gmail dot com or find me on GitHub


Source code for Model.Package.entries.entry
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from src.Model.Package.entries.base_entry import BaseEntry
from src.Model.Package.inconsistency import Inconsistency
__author__ = 'Ondřej Lanč'
[docs]class Entry(BaseEntry, Inconsistency):
"""This is basis class for all entries."""
def __init__(self, name, package):
BaseEntry.__init__(self, name, package)
self._help = None
self._parent = None
self._static_active = True
self._dynamic_active = True
self._multiple = False
self._group = None # Group of entry
self._inconsistent = False
def __deepcopy__(self, memo):
newone = type(self)(self.name, self.package)
newone.__dict__.update(self.__dict__)
newone._inc_parents = set()
return newone
@property
def parent(self):
"""get name"""
return self._parent
@parent.setter
def parent(self, parent):
"""set name"""
self.inc_parents.add(parent)
self._parent = parent
[docs] def is_container(self):
"""Return true if it is a container."""
raise NotImplementedError
[docs] def is_keyword(self):
"""Return true if it is a keyword."""
raise NotImplementedError
[docs] def is_multiple_entry_container(self):
"""Return true if it is a multiple container."""
raise NotImplementedError
@property
def full_name(self):
"""Return full path in current tree in form of: /a/b/c/..."""
path = "/" + self.name
if self.multiple:
path = path + "/" + str(self.index)
if self.parent:
path = self.parent.full_name + path
else:
path = ""
return path
@property
def help(self):
return self._help
@help.setter
def help(self, help):
self._help = help
@property
def group(self):
# Propagate group from entry's parent
return self._group or (
self.parent.group if self.parent is not None else None)
@group.setter
def group(self, group):
self._group = group
@property
def static_active(self):
"""Static activity indicates that the entry is switched on or off. Entries that are off are not processed in
the client and cannot be turned on by dependencies"""
return self._static_active
@static_active.setter
def static_active(self, active):
self._static_active = active
self._dynamic_active = active
@property
def active(self):
"""Dynamic activity is the activity set by dependencies"""
return self._static_active and self._dynamic_active
@active.setter
def active(self, active):
if not self._static_active and active:
from src.Model.exception import PropertyException
raise PropertyException(
"Key {} cannot be set active by a dependency,"
" because it is non inactive by template.".format(self.name))
self._dynamic_active = active
@property
def multiple(self):
return self._multiple
@multiple.setter
def multiple(self, multiple):
self._multiple = multiple
[docs] def set_default(self):
raise NotImplementedError


VSL // Stylin’
* Creatives Jo Tan and Markus Diebel
today’s Very Short List:
style 2 Apr 2014
Mike Del Ponte is founder and CEO at Soma
Subscribe
* This video
* What is a Man Repeller? “She who outfits herself in a sartorially offensive mode that may result in repelling members of the opposite sex.” Leandra Medine
http://link.nyobserver.com/516ca68465217dc6e1b9a3a61idie.bkb/UztIHeYQ7CeE9rFUCf81b very short list is a
delightful e-mail that shares
cultural gems from a
different curator every day.
If you have any problems reading this e-mail, click here
http://link.nyobserver.com/516ca68465217dc6e1b9a3a61idie.bkb/UztIHeYQ7CeE9rFWC086b
Subscribe
Forward
My Account
Unsubscribe
tech 31 Mar 2014
Emeka Ogbonna on tech that’s changing travel.
food 28 Mar 2014
indulges in breakfast.
culture 26 Mar 2014
Carly Ayres uncovers some hidden artistic details.
Editorial Policy
Privacy Policy
Contact Us
Press
Terms + Conditions
very fine print: ©2014
Observer VSL LLC.
321 West 44th Street, 6th Floor
New York, NY 10036 USA
All rights reserved.
Questions?<PHONE_NUMBER>.
This message was intended for<EMAIL_ADDRESS>If you believe this has been sent to you in error, please safely unsubscribe


April 2022 Status Update
Why hello there! It’s the first Tuesday of the month, which means it’s time for your next installment of starbeam.one monthly status updates.
Everything is on Fire…
Sometimes the expression “on fire” can be a good thing. Most of the times it is not. Currently, the state of this project is in the latter, unfortunately. Every day seems like a new challenge or something else breaking. I am currently attending to each one as the only person on this project at the moment and making due with the resources and limitations presented to me.
… but Still Pushing Forward
I’ve been at this for two years now and it’s been more or less the same sort of chaos. Technically, this is nothing new for me but now it’s in front of a larger audience. To further add to the grief, this was all due to my own decision to make it as such with my February announcement. 😅 Nonetheless, nothing has really changed and it’s business as usual, taking each issue as it arises and dealing with it.
Stand-up & Shine (& Shill)
After going a full month of weekly standups, I am rolling these back to semi-weekly due to their demand on me (or specifically, my time). It’s not just the day of filming, but the few days after that get me. For the month of April, I will be doing only one of these (today) to make up for the churn for the past month.
On the good news (there is good news here somewhere right? 😆) I have picked up 7 subscribers for my YouTube channel. Thank you to each and every one of you for your support!
No One is Talking about the Blockchain
As I mentioned earlier, I could have waited a bit longer to make an announcement and most of the grief thrown onto myself is my own doing. But, along with that comes a few takeaways. One of these is getting early feedback from artists and collectors. And the theme that seems to be emerging here is that: no one is talking about the blockchain.
… artists want to get paid, and patrons want to pay artists.
The bottom (timeless) line here is that artists want to get paid, and patrons want to pay artists. If you do that, then it doesn’t matter how you’ve done it: you’ve won. Everything else is just noise.
In fact, mentioning the blockchain might become a bit of a distraction/liability by pulling in unwanted (“get rich quick”) elements. So, going forward, you might see me reduce any mention of this altogether.
Front Page Adjustments
There was something I was able to get accomplished this past month, and that is the front page, now featuring better product tiles and clearer category types. You can filter on these types as well. Check it out and feel free to continue helping test the system.
Planned Features
Videos
I am currently attempting to implement video asset support, meaning creators can upload videos as an asset for their creations. This has introduced all sorts of problems for me in the past week in particular. However, I have been able to address most of them and should have something together here in the next day or so.
Preview Fields
What’s valuable about videos is that in addition to content, you can use them for marketing material. As such, adding preview fields to products has been mentioned several times as a wanted feature, so I am adding that this next month. With preview fields, you can add additional content that sort of shows off your product without actually showing the actual product. So, for instance, in the case of a 5 minute song, you can also upload a clip of 15-20 seconds. Preview fields can be images, audio, video, or text.
New Creation Workflow
Part of the friction that I am experiencing here is that all of this code is the first of the first code that I wrote two years ago. So it’s dated and could stand to improve. It’s not just the code but the processes as well. Everything basically captures process and business requirements but is difficult to understand unless you are familiar with it and understand the backing conceptual model.
However, it’s difficult to use. There are a lot of steps involved to issue new licenses and it could be made simpler. This is what I will be working on for the remainder of the month. Once that is done, I will be making a new push to start getting users to test out the process further and get to the next phase here.
Whatever that is. 😁
Schedule
Alright, so where are we right now? The way I see things, it’s:
- April: Refactoring/Fires/Video/Preview/Creator workflow
- May: Administration Application/Features
- June: Alpha Announcement?
- July: More Features
More Details
You can find out more with my monthly standup here:
That should do it for this month. Until next time, stay bright. ✨✌


EBD - Easton Bible DIctionary
Javelin
JAVELIN
"JAVELIN "(1.) Hebrews hanith, a lance, from its flexibility (
1 Samuel 18:10, 11
;
19:9, 10
;
20:33
).
(2.) Hebrews romah, a lance for heavy-armed troops, so called from its piercing (
Numbers 25:7
). (See ARMS.)
"JAVELIN "(1.) Hebrews hanith, a lance, from its flexibility (1 Samuel 18:10, 11; 19:9, 10; 20:33).
(2.) Hebrews romah, a lance for heavy-armed troops, so called from its piercing (Numbers 25:7). (See ARMS.)


It was an overcast morning in July. Pansy Cradledew was up and about at an ungodly hour. Some time later, her inamorato woke up, and, glugging his morning coffee, asked:
“So what have you been up to so early in the day, my sweet, my darling dear?”
“Oh, I pulled the head off a bat,” replied Pansy.
Her inamorato spluttered a mouthful of coffee and almost choked, until it became clear that the bat in question was not some flesh and blood and sinew pipistrelle, but a model bat made from terracotta-coloured modelling clay. Pansy, it transpired, had fashioned a figurine of the hideous bat god Fatso, his “look” based on the equally hideous bat god Camazotz, and the removal of the head was a temporary measure to expedite the drying and setting process. Nonetheless, her crack o' dawn activity led to the conversational exchange reported, causing much merriment and the splitting of sides.


Senior Machine Learning Engineer/ Data Scientist - Albany, CA
Eluvio uses a wide range of machine learning and deep learning techniques within its content fabric. This position offers an experienced scientist/engineer an opportunity for big impact, working in a small, excellent team innovating new ML, DL and data science solutions.
Responsibilities
- Build production level machine learning models on large-scale datasets to increase the intelligence of video/audio content
- Optimize content routing, re-use, transformation and delivery algorithms
- Provide data-driven recommendations and actionable insights on problems such as content understanding/augmentation/location
- Develop multi-functional learning pipelines
- Collaborate with product and engineering teams to implement models at scale
Requirements
- Master's Degree or PhD in Computer Science & Engineering/Statistics/Math/Physics
- Minimum of 1-3 years of working experience as a data scientist or machine learning engineer
- Expertise with Python or R
- Experience with machine/deep learning algorithms (e.g. gradient boosting, CNNs, sequence models) and frameworks/libraries (e.g. Tensorflow, PyTorch, Scikit-learn)
- Advanced SQL skills, comfortable working with very large data sets
- Previous experience in computer vision and natural language processing
- e.g. object detection, video/image/text classification, image captioning, image-to-image translation) is a plus
- Great communication skills, organized, able to multitask and be a team player
- Ability to balance attention to detail with agile execution
Benefits
Eluvio employees have salaries comensurate with experience as well as medical, dental, and vision insurance.


Greggs boss gives up steak bakes and sausage rolls to go vegan
The chief executive of Greggs won’t be able to enjoy a Festive Bake this year, as he has now gone vegan.
Roger Whiteside is three weeks into his new diet, but he didn’t make the change after trying one of the bakery chain’s famous vegan sausage rolls.
Instead, a documentary on Netflix called The Gamechangers inspired him to ditch the meat, milk and eggs.
Mr Whiteside said: ‘If you’d asked me three weeks ago which roll I preferred I would have said the original sausage roll, but I’m now attempting to live on a vegan diet.
‘Obviously there are arguments based around animal welfare and the environment, but this was all about the health benefits, and I thought I should give it a go.
‘Avoiding meat is easy. The problem is avoiding dairy, avoiding milk and cheese is almost impossible. It would be okay if I had time to cook, but I don’t, so I have to have things that are quick and easy.’
Luckily, his new food choices correspond with a potential expansion of the bakery’s vegan range, so he won’t have to starve while visiting the shop floor.
Advertisement Advertisement
They have introduced a vegan sweet mine pie in 2016 and also have a Mexican Bean & Sweet Potato Wrap available.
Mr Whiteside said he’s currently making his way through Greggs’ vegan range, which the firm is looking to expand, potentially adding vegan versions of other best-sellers like its steak bake.
He spoke about his new regime as he was awarded this year’s North East Business Executive of the Year in Newcastle.
‘It’s been seven years since I took over as CEO and we’ve spent all that time transforming the business in all sorts of ways, obviously refocusing the business away from traditional bakery to the growing food-on-the-go market,’ he said.
‘But really all that time has been spent on getting to the start line and what comes next for Greggs is to build on that platform to become truly multi-channel in a digital age.
‘And there’s so much opportunity to do that, serving customers at all times of the day, everywhere, in every way they want when they’re looking for food and drink away from home.
‘We’ve already started investing in these new channels – delivery of food, click and collect food, drive-thru lanes, food to order – all of those things are there to be developed by Greggs now.
‘As well as being market-leaders in bakery, which you’d expect with our heritage, we’re becoming market leaders in areas you’d never have thought of. So we’re already well on the way.’
Advertisement Advertisement
‘There’s lots to look forward to.’
Got a story for Metro.co.uk?
Get in touch with our news team by emailing us at<EMAIL_ADDRESS>For more stories like this, check our news page.


getINITModel Generates a model using the INIT algorithm, based on proteomics and/or transcriptomics and/or metabolomics and/or metabolic tasks. refModel a model structure. The model should be in the closed form (no exchange reactions open). Import using import(filename,false). If the model is not loaded using importModel, it might be that there is no "unconstrained" field. In that case, manually add the field like: model.unconstrained=false(numel(model.mets),1); tissue tissue to score for. Should exist in either hpaData.tissues or arrayData.tissues celltype cell type to score for. Should exist in either hpaData.celltypes or arrayData.celltypes for this tissue (opt, default is to use the best values among all the cell types for the tissue. Use [] if you want to supply more arguments) hpaData HPA data structure from parseHPA (opt if arrayData is supplied, default []) arrayData gene expression data structure (opt if hpaData is supplied, default []) genes cell array with the unique gene names tissues cell array with the tissue names. The list may not be unique, as there can be multiple cell types per tissue celltypes cell array with the cell type names for each tissue levels GENESxTISSUES array with the expression level for each gene in each tissue/celltype. NaN should be used when no measurement was performed metabolomicsData cell array with metabolite names that the model should produce (opt, default []) taskFile a task list in Excel format. See parseTaskList for details (opt, default []) useScoresForTasks true if the calculated reaction scored should be used as weights in the fitting to tasks (opt, default true) printReport true if a report should be printed to the screen (opt, default true) taskStructure task structure as from parseTaskList. Can be used as an alternative way to define tasks when Excel sheets are not suitable. Overrides taskFile (opt, default []) params parameter structure as used by getMILPParams. This is for the INIT algorithm. For the the MILP problems solved to fit tasks, see paramsFT (opt, default []) paramsFT parameter structure as used by getMILPParams. This is for the fitTasks step. For the INIT algorithm, see params (opt, default []) model the resulting model structure metProduction array that indicates which of the metabolites in metabolomicsData that could be produced. Note that this is before the gap-filling process to enable defined tasks. To see which metabolites that can be produced in the final model, use canProduce. -2: metabolite name not found in model -1: metabolite found, but it could not be produced 1: metabolite could be produced essentialRxnsForTasks cell array of the reactions which were essential to perform the tasks addedRxnsForTasks cell array of the reactions which were added in order to perform the tasks deletedDeadEndRxns cell array of reactions deleted because they could not carry flux (INIT requires a functional input model) deletedRxnsInINIT cell array of the reactions which were deleted by the INIT algorithm taskReport structure with the results for each task id cell array with the id of the task description cell array with the description of the task ok boolean array with true if the task was successful essential cell array with cell arrays of essential reactions for the task gapfill cell array of cell arrays of reactions included in the gap-filling for the task This is the main function for automatic reconstruction of models based on the INIT algorithm (PLoS Comput Biol. 2012;8(5):e1002518). Not all settings are possible using this function, and you may want to call the functions scoreModel, runINIT and fitTasks individually instead. NOTE: Exchange metabolites should normally not be removed from the model when using this approach, since checkTasks/fitTasks rely on putting specific constraints for each task. The INIT algorithm will remove exchange metabolites if any are present. Use importModel(file,false) to import a model with exchange metabolites remaining. Usage: [model metProduction essentialRxnsForTasks addedRxnsForTasks... deletedDeadEndRxns deletedRxnsInINIT taskReport]=... getINITModel(refModel, tissue, celltype, hpaData, arrayData,... metabolomicsData, taskFile, useScoresForTasks, printReport,... taskStructure, params, paramsFT) Rasmus Agren, 2014-01-08
0001 function [model, metProduction, essentialRxnsForTasks, addedRxnsForTasks, deletedDeadEndRxns, deletedRxnsInINIT, taskReport]=getINITModel(refModel, tissue, celltype, hpaData, arrayData, metabolomicsData, taskFile, useScoresForTasks, printReport, taskStructure, params, paramsFT) 0002 % getINITModel 0003 % Generates a model using the INIT algorithm, based on proteomics and/or 0004 % transcriptomics and/or metabolomics and/or metabolic tasks. 0005 % 0006 % refModel a model structure. The model should be in the 0007 % closed form (no exchange reactions open). Import 0008 % using import(filename,false). If the model is not 0009 % loaded using importModel, it might be that there 0010 % is no "unconstrained" field. In that case, 0011 % manually add the field like: 0012 % model.unconstrained=false(numel(model.mets),1); 0013 % tissue tissue to score for. Should exist in either 0014 % hpaData.tissues or arrayData.tissues 0015 % celltype cell type to score for. Should exist in either 0016 % hpaData.celltypes or arrayData.celltypes for this 0017 % tissue (opt, default is to use the best values 0018 % among all the cell types for the tissue. Use [] if 0019 % you want to supply more arguments) 0020 % hpaData HPA data structure from parseHPA (opt if arrayData is 0021 % supplied, default []) 0022 % arrayData gene expression data structure (opt if hpaData is 0023 % supplied, default []) 0024 % genes cell array with the unique gene names 0025 % tissues cell array with the tissue names. The list may not be 0026 % unique, as there can be multiple cell types per tissue 0027 % celltypes cell array with the cell type names for each tissue 0028 % levels GENESxTISSUES array with the expression level for 0029 % each gene in each tissue/celltype. NaN should be 0030 % used when no measurement was performed 0031 % metabolomicsData cell array with metabolite names that the model 0032 % should produce (opt, default []) 0033 % taskFile a task list in Excel format. See parseTaskList for 0034 % details (opt, default []) 0035 % useScoresForTasks true if the calculated reaction scored should be used as 0036 % weights in the fitting to tasks (opt, default true) 0037 % printReport true if a report should be printed to the screen 0038 % (opt, default true) 0039 % taskStructure task structure as from parseTaskList. Can be used 0040 % as an alternative way to define tasks when Excel 0041 % sheets are not suitable. Overrides taskFile (opt, 0042 % default []) 0043 % params parameter structure as used by getMILPParams. This is 0044 % for the INIT algorithm. For the the MILP problems 0045 % solved to fit tasks, see paramsFT (opt, default []) 0046 % paramsFT parameter structure as used by getMILPParams. This is 0047 % for the fitTasks step. For the INIT algorithm, see 0048 % params (opt, default []) 0049 % 0050 % model the resulting model structure 0051 % metProduction array that indicates which of the 0052 % metabolites in metabolomicsData that could be 0053 % produced. Note that this is before the 0054 % gap-filling process to enable defined tasks. To 0055 % see which metabolites that can be produced in 0056 % the final model, use canProduce. 0057 % -2: metabolite name not found in model 0058 % -1: metabolite found, but it could not be produced 0059 % 1: metabolite could be produced 0060 % essentialRxnsForTasks cell array of the reactions which were 0061 % essential to perform the tasks 0062 % addedRxnsForTasks cell array of the reactions which were added in 0063 % order to perform the tasks 0064 % deletedDeadEndRxns cell array of reactions deleted because they 0065 % could not carry flux (INIT requires a 0066 % functional input model) 0067 % deletedRxnsInINIT cell array of the reactions which were deleted by 0068 % the INIT algorithm 0069 % taskReport structure with the results for each task 0070 % id cell array with the id of the task 0071 % description cell array with the description of the task 0072 % ok boolean array with true if the task was successful 0073 % essential cell array with cell arrays of essential 0074 % reactions for the task 0075 % gapfill cell array of cell arrays of reactions included 0076 % in the gap-filling for the task 0077 % 0078 % This is the main function for automatic reconstruction of models based 0079 % on the INIT algorithm (PLoS Comput Biol. 2012;8(5):e1002518). Not all 0080 % settings are possible using this function, and you may want to call the 0081 % functions scoreModel, runINIT and fitTasks individually instead. 0082 % 0083 % NOTE: Exchange metabolites should normally not be removed from the model 0084 % when using this approach, since checkTasks/fitTasks rely on putting specific 0085 % constraints for each task. The INIT algorithm will remove exchange metabolites 0086 % if any are present. Use importModel(file,false) to import a model with 0087 % exchange metabolites remaining. 0088 % 0089 % Usage: [model metProduction essentialRxnsForTasks addedRxnsForTasks... 0090 % deletedDeadEndRxns deletedRxnsInINIT taskReport]=... 0091 % getINITModel(refModel, tissue, celltype, hpaData, arrayData,... 0092 % metabolomicsData, taskFile, useScoresForTasks, printReport,... 0093 % taskStructure, params, paramsFT) 0094 % 0095 % Rasmus Agren, 2014-01-08 0096 % 0097 0098 if nargin<3 0099 celltype=[]; 0100 end 0101 if nargin<4 0102 hpaData=[]; 0103 end 0104 if nargin<5 0105 arrayData=[]; 0106 end 0107 if nargin<6 0108 metabolomicsData=[]; 0109 end 0110 if nargin<7 0111 taskFile=[]; 0112 end 0113 if nargin<8 0114 useScoresForTasks=true; 0115 end 0116 if nargin<9 0117 printReport=true; 0118 end 0119 if nargin<10 0120 taskStructure=[]; 0121 end 0122 if nargin<11 0123 params=[]; 0124 end 0125 if nargin<12 0126 paramsFT=[]; 0127 end 0128 0129 %Check that the model is in the closed form 0130 if ~isfield(refModel,'unconstrained') 0131 EM='Exchange metabolites should normally not be removed from the model when using getINITModel. Use importModel(file,false) to import a model with exchange metabolites remaining (see the documentation for details)'; 0132 dispEM(EM); 0133 end 0134 0135 %Create the task structure if not supplied 0136 if any(taskFile) && isempty(taskStructure) 0137 taskStructure=parseTaskList(taskFile); 0138 end 0139 0140 if printReport==true 0141 if any(celltype) 0142 fprintf(['***Generating model for: ' tissue ' - ' celltype '\n']); 0143 else 0144 fprintf(['***Generating model for: ' tissue '\n']); 0145 end 0146 if ~isempty(hpaData) 0147 fprintf('-Using HPA data\n'); 0148 end 0149 if ~isempty(arrayData) 0150 fprintf('-Using array data\n'); 0151 end 0152 if ~isempty(metabolomicsData) 0153 fprintf('-Using metabolomics data\n'); 0154 end 0155 if any(taskFile) 0156 fprintf('-Using metabolic tasks\n'); 0157 end 0158 fprintf('\n'); 0159 0160 printScores(refModel,'Reference model statistics',hpaData,arrayData,tissue,celltype); 0161 end 0162 0163 %Remove dead-end reactions to speed up the optimization and to 0164 %differentiate between reactions removed by INIT and those that are 0165 %dead-end 0166 [~, deletedDeadEndRxns]=simplifyModel(refModel,true,false,true,true,true); 0167 cModel=removeReactions(refModel,deletedDeadEndRxns,false,true); 0168 0169 %Store the connected model like this to keep track of stuff 0170 if printReport==true 0171 printScores(cModel,'Pruned model statistics',hpaData,arrayData,tissue,celltype); 0172 end 0173 0174 %If tasks have been defined, then go through them and get essential 0175 %reactions 0176 if ~isempty(taskStructure) 0177 [taskReport, essentialRxnMat]=checkTasks(cModel,[],printReport,true,true,taskStructure); 0178 0179 essentialRxnsForTasks=cModel.rxns(any(essentialRxnMat,2)); 0180 0181 %Remove tasks that cannot be performed 0182 taskStructure(taskReport.ok==false)=[]; 0183 if printReport==true 0184 printScores(removeReactions(cModel,setdiff(cModel.rxns,essentialRxnsForTasks),true,true),'Reactions essential for tasks',hpaData,arrayData,tissue,celltype); 0185 end 0186 else 0187 essentialRxnsForTasks={}; 0188 end 0189 0190 %Score the connected model 0191 [rxnScores, geneScores]=scoreModel(cModel,hpaData,arrayData,tissue,celltype); 0192 0193 %Run the INIT algorithm. The exchange reactions that are used in the final 0194 %reactions will be open, which doesn't fit with the last step. Therefore 0195 %delete reactions from the original model instead of taking the output. 0196 %The default implementation does not constrain reversible reactions to only 0197 %carry flux in one direction. 0198 %Runs without the constraints on reversibility and with all output allowed. 0199 %This is to reduce the complexity of the problem. 0200 [~, deletedRxnsInINIT, metProduction]=runINIT(simplifyModel(cModel),rxnScores,metabolomicsData,essentialRxnsForTasks,0,true,false,params); 0201 initModel=removeReactions(cModel,deletedRxnsInINIT,true,true); 0202 if printReport==true 0203 printScores(initModel,'INIT model statistics',hpaData,arrayData,tissue,celltype); 0204 printScores(removeReactions(cModel,setdiff(cModel.rxns,deletedRxnsInINIT),true,true),'Reactions deleted by INIT',hpaData,arrayData,tissue,celltype); 0205 end 0206 0207 %The full model has exchange reactions in it. fitTasks calls on fillGaps, 0208 %which automatically removes exchange metabolites (because it assumes that 0209 %the reactions are constrained when appropriate). In this case the 0210 %uptakes/outputs are retrieved from the task sheet instead. To prevent 0211 %exchange reactions being used to fill gaps, they are delete from the 0212 %reference model here. 0213 initModel.id='INITModel'; 0214 0215 %If gaps in the model should be filled using a task list 0216 if ~isempty(taskStructure) 0217 %Remove exchange reactions and reactions already included in the INIT 0218 %model 0219 refModelNoExc=removeReactions(refModel,union(initModel.rxns,getExchangeRxns(refModel)),true,true); 0220 0221 %At this stage the model is fully connected and most of the genes with 0222 %good scores should have been included. The final gap-filling should 0223 %take the scores of the genes into account, so that "rather bad" 0224 %reactions are preferred to "very bad" reactions. However, reactions 0225 %with positive scores will be included even if they are not connected 0226 %in the current formulation. Therefore, such reactions will have to be 0227 %assigned a small negative score instead. 0228 if useScoresForTasks==true 0229 refRxnScores=scoreModel(refModelNoExc,hpaData,arrayData,tissue,celltype); 0230 [outModel, addedRxnMat]=fitTasks(initModel,refModelNoExc,[],true,min(refRxnScores,-0.1),taskStructure,paramsFT); 0231 else 0232 [outModel, addedRxnMat]=fitTasks(initModel,refModelNoExc,[],true,[],taskStructure,paramsFT); 0233 end 0234 if printReport==true 0235 printScores(outModel,'Functional model statistics',hpaData,arrayData,tissue,celltype); 0236 printScores(removeReactions(outModel,intersect(outModel.rxns,initModel.rxns),true,true),'Reactions added to perform the tasks',hpaData,arrayData,tissue,celltype); 0237 end 0238 0239 addedRxnsForTasks=refModelNoExc.rxns(any(addedRxnMat,2)); 0240 else 0241 outModel=initModel; 0242 addedRxnMat=[]; 0243 addedRxnsForTasks={}; 0244 end 0245 0246 %The model can now perform all the tasks defined in the task list. The 0247 %algorithm cannot deal with gene-complexes at the moment. It is therefore 0248 %ok to remove bad genes from a reaction (as long as at least one gene is 0249 %kept) 0250 model=outModel; 0251 0252 [~, I]=ismember(model.genes,cModel.genes); %All should be found 0253 %This is a little weird way to make sure that only one bad gene is included 0254 %if there are no good ones (since all -Inf==max(-Inf)) 0255 geneScores(isinf(geneScores))=-1000+rand(sum(isinf(geneScores)),1); 0256 0257 model.grRules(:)={''}; 0258 for i=1:numel(model.rxns) 0259 ids=find(model.rxnGeneMat(i,:)); 0260 if numel(ids)>1 0261 scores=geneScores(I(ids)); 0262 %Only keep the positive ones if possible 0263 model.rxnGeneMat(i,ids(~(scores>0 | scores==max(scores))))=0; 0264 end 0265 %Rewrite the grRules to be only OR 0266 if isfield(model,'grRules') 0267 J=find(model.rxnGeneMat(i,:)); 0268 for j=1:numel(J) 0269 model.grRules{i}=[model.grRules{i} '(' model.genes{J(j)} ')']; 0270 if j<numel(J) 0271 model.grRules{i}=[model.grRules{i} ' or ']; 0272 end 0273 end 0274 end 0275 end 0276 0277 %Find all genes that are not used and delete them 0278 I=sum(model.rxnGeneMat)==0; 0279 model.genes(I)=[]; 0280 model.rxnGeneMat(:,I)=[]; 0281 if isfield(model,'geneShortNames') 0282 model.geneShortNames(I)=[]; 0283 end 0284 if isfield(model,'geneMiriams') 0285 model.geneMiriams(I)=[]; 0286 end 0287 if isfield(model,'geneFrom') 0288 model.geneFrom(I)=[]; 0289 end 0290 if isfield(model,'geneComps') 0291 model.geneComps(I)=[]; 0292 end 0293 0294 %At this stage the model will contain some exchange reactions but probably not all 0295 %(and maybe zero). This can be inconvenient, so all exchange reactions from the 0296 %reference model are added, except for those which involve metabolites that 0297 %are not in the model. 0298 0299 %First delete and included exchange reactions in order to prevent the order 0300 %from changing 0301 model=removeReactions(model,getExchangeRxns(model)); 0302 0303 %Create a model with only the exchange reactions in refModel 0304 excModel=removeReactions(refModel,setdiff(refModel.rxns,getExchangeRxns(refModel)),true,true); 0305 0306 %Find the metabolites there which are not exchange metabolites and which do 0307 %not exist in the output model 0308 I=~ismember(excModel.mets,model.mets) & excModel.unconstrained==0; 0309 0310 %Then find those reactions and delete them 0311 [~, J]=find(excModel.S(I,:)); 0312 excModel=removeReactions(excModel,J,true,true); 0313 0314 %Merge with the output model 0315 model=mergeModels({model;excModel}); 0316 model.id='INITModel'; 0317 model.description=['Automatically generated model for ' tissue]; 0318 if any(celltype) 0319 model.description=[model.description ' - ' celltype]; 0320 end 0321 0322 if printReport==true 0323 printScores(model,'Final model statistics',hpaData,arrayData,tissue,celltype); 0324 end 0325 0326 %Add information about essential reactions and reactions included for 0327 %gap-filling and return a taskReport 0328 if ~isempty(taskStructure) 0329 I=find(taskReport.ok); %Ignore failed tasks 0330 for i=1:numel(I) 0331 taskReport.essential{I(i),1}=cModel.rxns(essentialRxnMat(:,I(i))); 0332 taskReport.gapfill{I(i),1}=refModelNoExc.rxns(addedRxnMat(:,i)); 0333 end 0334 else 0335 taskReport=[]; 0336 end 0337 end 0338 0339 %This is for printing a summary of a model 0340 function [rxnS, geneS]=printScores(model,name,hpaData,arrayData,tissue,celltype) 0341 [a, b]=scoreModel(model,hpaData,arrayData,tissue,celltype); 0342 rxnS=mean(a); 0343 geneS=mean(b(~isinf(b))); 0344 fprintf([name ':\n']); 0345 fprintf(['\t' num2str(numel(model.rxns)) ' reactions, ' num2str(numel(model.genes)) ' genes\n']); 0346 fprintf(['\tMean reaction score: ' num2str(rxnS) '\n']); 0347 fprintf(['\tMean gene score: ' num2str(geneS) '\n']); 0348 fprintf(['\tReactions with positive scores: ' num2str(100*sum(a>0)/numel(a)) '%%\n\n']); 0349 end


Are you confuse on which programming languages to learn? Please complete the survey form to check which best programming languages is the right one for you.
Hello ,
Thank you for completing the survey. Below are the three best tracks for you:
CSS/Design
Java/Android
PHP/Drupal
Ruby/Rails
C#/.Net
"Everybody in this country should learn to program a computer... because it teaches you how to think"


@Target([AnnotationTarget.CLASS]) annotation class ConnectorIdHandlers
(source)
Annotation used to annotate StoryHandlerDefinitionBase implementation, in order to provide ConnectorStoryHandler for each connector id. Used only by connector implementation.
<init> |
Annotation used to annotate StoryHandlerDefinitionBase implementation, in order to provide ConnectorStoryHandler for each connector id. Used only by connector implementation. ConnectorIdHandlers(vararg handlers: ConnectorIdHandler) |
handlers |
vararg val handlers: Array<out ConnectorIdHandler> |


Accordingly to Wikipedia, SQL injection is a code injection technique, used to attack data-driven applications, in which malicious SQL statements are inserted into an entry field for execution. It is one of the most common application layer attack techniques, and the issue arises because web applications allow users to insert SQL statements to query the database directly. It occurs when a hacker attempts to pass SQL commands through a web application, and he or she could achieve successful attacks that enable him or her to view information in the database or even purge it if the database inputs are not sanitized properly. Take a simple login page where a user would enter his or her login id and password to gain access to his or her credentials. SQL query is generated from these inputs and submitted to the database for verification. Once verified, the legitimate user would be granted appropriate access. A hacker can try to bypass the verification stage in order to retrieve the sensitive data behind it through a well-crafted SQL commands. Lastly, it's good to note that a hacker is not a master-minded thief. He or she only needs a web browser, in-depth knowledge of SQL, and creative guess work to carry out the attacks. Click here if you are interested in few examples of SQL commands that can lead to SQL injection. Firewall and similar attack detection software provide little or no defense against full-scale SQL injection attacks. The Open Web Application Security Project (OWASP), a not-for-profit charitable organization focused on improving the security of software, provides a cheat sheet on SQL injection prevention. It lists three options for primary defenses against SQL injection. Option #1: Use of Prepared Statements (Parameterized Queries) Option #2: Use of Stored Procedures Option #3: Escaping all User Supplied Input The first option works by forcing the user to to define all SQL code, and then pass in each parameter to the query later. The database takes in this style of code and is able to distinguish between code and data and ensure a hacker is not able to change the purpose of the query. The second option is just like using prepared statements, but the difference is that SQL code for a stored procedure is defined and stored in the database, and then called from the application. The last option involves escaping user input before putting it in a query. It's not a recommended method, but it could prove to be useful if you are concerned about rewriting queries as prepared statements or stored procedures might negatively affect your application.


--- layout: post title: "The Week in Predictions" date: 2017-06-17 10:30:00 +0000 tags: image: https://s3.amazonaws.com/contrafabulists/2017-06-17-predict.jpg imagecredits: https://www.flickr.com/photos/an_untrained_eye/3075008647 ---
The Contrafabulists monitor predictions that technologists and marketers make each week about the future of technology:
“Robots will take over half of today’s jobs in 10–20 years,” according to MarketWatch. There’s even a graph, so it must be true.


HackUSU Events Calendar
Calendar
Categories
Login
Create New User
Projects
Add Event
Search
Create Event
Event:
Date:
Time:
Picture:
Description:
Categories
Create
Sidebar


US Navy carrier transits Strait of Hormuz after deployment
DUBAI, United Arab Emirates (AP) - A U.S. aircraft carrier ordered by the White House to rapidly deploy to the Mideast over a perceived threat from Iran has transited the Strait of Hormuz for the first time since its deployment.
The U.S. Navy says the USS Abraham Lincoln transited the strait on Tuesday, making its way to the Persian Gulf. The carrier left Norfolk, VA, in April and was diverted to the Middle East in May, but it had remained in the Arabian Sea, avoiding passage through the strait that borders Iran.
American aircraft carriers have for decades sailed through the international oil shipping route in what the U.S. describes as “defensive” operations aimed at keeping the strait open.
The Trump administration deployed the Lincoln to the Persian Gulf amid a spike in tensions with Iran.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


{% extends 'base.html' %} {% block title %}BRUR Online Payment{% endblock title %} {% block content %}
If you paid more than amount required please contact your department
If you paid less than the amount required please rest amount using same method and same account. Also don't forget to provide your roll number as reference. Make a note of your new transaction id and click here
Please click here to update your information


No destructors in Java (You can set a
reference null)
Enums: Have You Seen Something Like This?
public class PaperType extends AbstractType implements Serializable {
private static final Map NAME_MAP = new HashMap();
/**
* String constant.
*/
public static final String MALE_STR = "MALE";
/**
* String constant.
*/
public static final String FEMALE_STR = "FEMALE";
/**
* String constant.
*/
public static final String COUPLE_STR = "COUPLE";
/**
* String constant.
*/
public static final String EITHER_STR = "EITHER";
/**
* Male paper type.
*/
public static final PaperType MALE = new PaperType(MALE_STR);
/**
* Feale paper type.
*/
public static final PaperType FEMALE = new PaperType(FEMALE_STR);
/**
* Couple paper type.
*/
public static final PaperType COUPLE = new PaperType(COUPLE_STR);
/**
Enums: When to use them?
Types are a good example
If you have several options, as in a switch statement. (flip side: Really think if you should use real types)
if(paperType.equals(org.familysearch.temple.types.PaperType.COUPLE_STR)){
// do stuff with couple paper type
}
else if(paperType.equals(org.familysearch.temple.types.PaperType.FEMALE_STR)){
// do something else
}
switch (paperType) {
case COUPLE:
break;
case FEMALE:
break;
}
Clean label
If the only thing that is different is the type,
don't use real types (think of switch with instanceof)


HOME
{{ photo }}
{{fullName}}
0 stars
{{appt}}
Contact Info
Availability
Services offered
Contact me:
Phone:
{{phone}}
Email:
{{email}}
{{ hours }}
{{ services }} {{ appt }} {{ rateme }} {{ reviews }}
{{ favButton }}
{{flagbutton}}