class: center, middle ### W4995 Applied Machine Learning # Tools and Infrastructure 01/22/18 Andreas C. Müller ??? Hey. Welcome to the second lecture on applied machine learning. Last week we talked a bit about very general and high-level issues in machine learning. Today, we’ll go right down to the metal. Actually, things we will talk about today are more generally about software engineering and less specifically about machine learning. If you want to build real-world systems, software engineering practices are really incredibly important. For those of you from CS, I hope this is a reminder, for those of you from DSI, some this is maybe new. We’ll talk about version control, in particular git, about some basic python, about testing, continuous integration and about documentation. Also, I apologize in advance for the slides. There’s a lot of bullet points and few diagrams and I don’t really like that. --- class: middle # So you think you know git? ??? So this first part is about git. I assume you all know about git. Who here has not used git so far? If you haven’t this might be a bit steep for you, and you should read up on it later. Let me know if I’m going to fast. I assume that you know what version control is and why it’s important. You should really use version control any time you work on any code or any other document. And it looks like we’ll have to use git for now and some time to come. So you all have used git, but who of you thinks they understand git? Ok I’ll keep you in mind and ask you trick questions along the way. --- class: center, middle ![:scale 40%](images/git_xkcd.png) ??? Here’s a comic from xkcd that might seem familiar. I know many people that use git by just memorizing some commands and if things go south, they just delete the repository and start fresh. Who of you have done that? I certainly have. The goal of today is that you never have to throw your hands up ever again. --- class: center, middle ![:scale 40%](images/torvalds_ducreux.jpg) ??? Personally I like to think that git was a practical joke played on the open source community by Linux Torvals. Unfortunately, I think the real issue is that kernel developers, genius as they might be, are not the best at creating user interfaces. Git is great, but the user interface is horrible. But let’s try and understand what’s going on. --- # Git Basics - Repository `$ git init` `$ rm .git` ??? There are some basic units of git that I want to go through. The first is a repository. What’s a repository? A folder who’s content we want to track with version control. And how can you create one? Run git init in a folder. And how can you make a folder not a repository any more? By removing the .git subfolder. That’s it. A repository is entirely self-contained. There is no service or database or anything like that, it’s all plain files within that folder. That also means if you remove the folder, you lose everything if you don’t have a backup. The next basic concept is a commit. What’s that? It’s a snapshot of the state of the folder, with a message attached, and identified with an ID. It’s also a node in a graph that describes the history of the snapshot, and usually has one or two parents, and can have arbitrary many children. The ID is a hash of the state and all the parents, so if you change anything, you change the hash and therefore the commit. The last basic concept I want to talk about is the remote. That’s just a pointer to another repository, often github, but it could also just be another folder on your computer. You can synchronize with that by pushing or pulling changes. -- - Commit -- - Remote --- # Typical Workflow - Clone - Branch - Add, commit, add, commit, add, commit, ... - Merge / rebase - Push ??? So here’s a typical workflow for making a change to an existing project. You clone the project from some remote repository. You change some files, add them, and commit them. Then you push them to the remote repository. That’s more or less what you’ll do with your homework. The advanced version of this is after cloning you create a branch, you make all your changes on the branch, and once you’re done, you merge the changes from your branch into the master branch. Everybody good so far? I want to give some basic tips that will help you even with these simple workflows. --- # Some tips - `$ git status` - Install shell plugins for status and branch (`oh-my-zsh`) ![:scale 90%](images/git_shell_extension.png) - Set editor, pager and diff-tool (check out meld!) - Use `.gitignore` ??? You should always call git status, to see what’s happening with your repository. It will tell you whether you changed anything, and which branch you’re on. I actually highly recommend using a plugin for your shell, that will give you the status in every line. If you use zsh, you can use oh-my-zsh for example. If you use something else like bash, there are also plenty of options out there. You should also set your editor and pager to something that is familiar to you. The default editor is vim, and if you’re not a vim user, you might want to change that. It’s also helpful to set up a diff program that you like. I like meld for example, that allows you to compare whole folders in a nice way. You should also use gitignore. It's a simple text file that allows you to ignore certain files or folders or file types. For example, you could ignore all .pyc files. Or you could ignore all .ipynb-checkpoints or your dataset folder. --- # Git log ![:scale 80%](images/git_log.png) ??? You should also become friends with git log. Git log allows you to view the history of your repository. It has a couple of very helpful options. Plain git log will have very long output and show full commit messages. If you want short summaries, use oneline. Often, it’s also useful to annotate branches, which you can do with A the decorate option. If you want to show more than just the branch you’re on, you can use the all option. Now it’s a bit hard to track the relations of the different commits, though, and you might want to use the graph option to show the structure of the history. You might want to alias a command like that because it’s rather long to type, but very informative. I’ll show you an alternative in a bit. --- class: center, middle ![:scale 50%](images/git_adog.png) ??? --- # Understanding Git - Working directory - Repository (Commit graph, history) - Index (Staging Area) - Branches - Head ??? So now, I want to work towards really understanding git, and here are some lower level concepts that are important. First, the working directory. That’s the actual current content of the folder on disk. Then there is a graph of commits, also known as the history. Formally that's called the repository, though usually I think of the repository as the whole thing. It's a directed acyclic graph that contains all the changes and contains the information about the parents of a commit. Then the index. The index is what's also called the staging area, it's an intermediate space in which you accumulate changes you want to put in a commit. Branches are quite simple. They are just pointers to particular commits. They point to certain commits. Head is another pointer. Head points to the current active branch. That is the branch that will be updated if you make a commit. (unless you’re on no branch, in which case you are headless) The state of you repository is really much more than the state of the directory, it’s the state of all of these five things together. And if you think about commands, you should think about them in terms of what they do to each of these five. --- # git Commands .smaller[ - .normal[`git add`]
puts files from working director into staging area (index) If not tracked so far, adds them to tracked files. - .normal[`git commit`]
commits files from staging area (index) to repository, moves current branch with HEAD - .normal[`git checkout [
] [
]`]
Set `
` in working directory to state at `
` and stages it. - .normal[`git checkout [-b]
`]
moves HEAD to `
` (-b creates it), changes content of working dir - .normal[`git reset --soft
`]
moves HEAD to `
` (takes the current branch with it) - .normal[`git reset --mixed
`]
moves HEAD to `
`, changes index to be at `
` (but not working directory) - .normal[`git reset --hard
`]
moved HEAD to `
`, changes index and working tree to `
`. ] ??? Ok so now, let’s got through some of the commands and talk about what they do in terms of these five concepts [read slide] --- class: center ![:scale 60%](images/git_data_transport.png) ??? I found this data flow diagram online and I think it's quite helpful for a subset of the commands. It shows how you can propagate changes from the working directory to a remote repository and back. This is only a small part of all the commands, though. For example reset is missing, and generally nothing that moves branches or head is here. --- # Merge - Fast-forward merge: ![:scale 90%](images/git_fast_forward_merge.png) - Merge-commits: ![:scale 90%](images/git_merge_commit.png) ??? Now let's talk about the the more complex operations to the repository or history, merging and rebasing. They change the commit graph, and possibly the working tree. I find it most helpful to think of them as graph operations on the repository. Let's start with merges. There’s two kinds of merging: feed-forward merges, and merges that require a commit. If one commit is a descendants of the other and you merge them, it will be a feed-forward, and just move the branch. That happens for example if you just pull new changes from a remote repository that you cloned, if you haven't made any local changes. However, if one isn’t a descendant of the other, git will create a “merge commit” that will unite the two, and have both as its parent. Git will attempt its best but if there’s conflicting changes, you might need to resolve the conflicts by hand. --- # Rebase - Rebase
![:scale 50%](images/git_rebase1.png) - Rebase onto
`git rebase --onto master next` .left-column[ ![:scale 80%](images/git_rebase2.png) ] .right-column[ ![:scale 80%](images/git_rebase3.png) ] ??? Rebase is a whole different beast. It allows more or less arbitrary modifications of the graph, and therefore rewriting history. You should be aware that if you use rebase, you will change a commit's hash because the hash depends on the history. Basically what rebase does is place a range of commits on top of another commit. If you're on branch A and you do git rebase B (or any other commit), what will happen is that it will find the common ancestor, take everything up to that ancestor, and place it on branch B. You can change the commit that it puts the changes on top of by using the --onto flag. So if I want to take the last five changes I do git rebase HEAD~5 --onto B That will take the common ancestor with HEAD~5, which is HEAD~5, and place it onto B. --- # Interactive rebase `git rebase -i
` ![:scale 66%](images/git_interactive_rebase.png) ??? You can make rebase even more complicated - and powerful, by making it interactive. While you could make any rebase interactive, it’s most common to rebase on an ancestor with interactive – in this case a non-interactive rebase would have no consequences. For each commit in the range that you want to rebase, interactive rebase allows you to pick the commit, which is leave it alone, squash it, which means incorporating it into the previous commit, removing it or amending it.  Rebasing can also create conflicts that need to be resolved the same way as merge conflicts. However, rebasing “plays back” all the commits that you moved on top of the target commit. That means that you might have to resolve conflicts on the same file multiple times – which you probably want to avoid. A good way to get around that is to squash all the commits you want to rebase into a single one, and then rebase that single commit. That means you only have to do conflict resolution once. So before you do a rebase on a different branch, you might do an interactive rebase to squash some commits and make conflict resolution easier. --- # Interactive adding ![:scale 55%](images/git_interactive_add.png) ??? What I find even more important is interactive adding. With git add, you usually add whole files to the staging area. I rarely ever do that. Usually I want to check line by line what changes I made and what changes I want to commit. Git add -i allows me to through all the different hunks or lines I changed. However, the command line interface is a bit clumsy for my taste. Or maybe I’m just not as used to it. I prefer a gui, which you can summon with git gui on the command line. --- class: center, middle # git gui ![:scale 80%](images/git_gui.png) ??? Git gui is basically an interface for git add and git commit. You can also use it to push, but not much more. This is the way I create most of my commits. You can see very easily which files have changed, see the changes, and stage single lines or whole files.  Another tool that I use all the time is gitk. This is basically a graphical interface to git log, showing you the history of your project. But you can also use it as a graphical interface for reset, and for cherry-picking, which we won’t go into. Often I run gitk with gitk –all, which will show you all the branches. This is quite similar to the Git log –oneline –anotate –graph –all that I did earlier – but now in a gui! This is usually how I do resets and how I look at the graph before I do any merges or rebases. You can also use gitk to search commit messages, and there are many option on what to display and how. I mostly use the options to selectively show some branches that I’m interested in. --- # reflog .left-column[ `$ git reflog` ![:scale 100%](images/git_reflog.png) ] .right-column[
![:scale 100%](images/git_simple_merge_graph.png) ] ??? The last command I want to mention is reflog. Reflog is a very powerful tool that allows you to go through the history of your project, but not the same was as log. Reflog actually tracks the changes to HEAD that you do with all the crazy commands that we talked about. Log and gitk will only show you commits that are part of branches. If you do a rebase, for example, all the previous commits are still there, but not part of a branch any more. Remember, rebasing creates new hashes, so the rebased commits are different commits. Imagine you want to go back to some states that are not part of any branch any more. Reflog allows you to do that. So if you break something during a rebase, or you lost a commit, you can always find it with reflog! --- class: center, middle # Git for ages 4 and up: https://www.youtube.com/watch?v=1ffBJ4sVUb4 (with play-doh!) ??? For some of you, this was probably too slow, and for some of you, this was probably too fast. Who here knew already all of this? So for those of you who I managed to totally confuse, I recommend you go through these slides again, and also watch this video. It’s pretty good, but it’s also pretty long. And for those of you who though this was wayyy to much detail: this was still not all the important parts. There’s also tags, and bare repositories and the stash and cherries... --- class: center, middle # Github - just another remote ??? I want to just briefly talk about github. For the purposes of git, github is just another remote. And it’s really nothing special. In terms of being a remote, you can replace github with a usb stick that you hand around. There is a lot of tools for user management and issue tracking which is great, but not really central what we’re talking about here. The main thing that’s different in using github from using any other remote, is the use of pull requests, and the ability to integrate with remote services. For now lets talk about pull requests, we'll come back to the services later. --- class: center # Github pull request workflow
![:scale 50%](images/forks1.png) ??? So what are pull requests for? Basically they allow you to contribute to a repository to which you don’t have write permissions. Let’s say you want to contribute to scikit-learn. Or to the lecture slides. There’s the main repository, which we usually call "upstream", scikit-learn/scikit-learn. You want to change something there, but you don’t have write permissions. --- class: center # Github pull request workflow
![:scale 50%](images/forks2.png) ??? What you can do is "fork" it on github – that’s a github concept, not a git concept. It’s just a clone that also lives on github. --- class: center # Github pull request workflow
![:scale 50%](images/forks3.png) ??? To actually make any changes, you can then clone this fork locally, add a feature branch, make changes and push them. --- class: center # Github pull request workflow
![:scale 50%](images/forks.png) ??? Then you can ask the owner of the repository if they want to merge your changes. That's a pull request and allows the owner to "pull" in your changes into the main repository. So far, so good. Makes mostly sense, I think. There is a slight oddity in this workflow, though. --- class: center # Github pull request workflow
![:scale 60%](images/forks_master_feature.png) ??? Usually you pull the current status from the master branch, and make some changes that you want to include. So you always pull master and push feature branches. But the code in the upstream repository changes. How do you get these changes onto your laptop? If the original repository gets updated, there is no way to directly update your fork. --- class: center # Github pull request workflow
![:scale 60%](images/forks_master_feature2.png) ??? You have to add upstream as an additional remote, and then you can pull from there. You can create new features on top, and push the feature branches to your fork (which is usually the “origin” remote).  It never gets updated and there is no point in pushing to it, so it will just sit there and rot, staying at the state of the original repository at the time of your fork. I think that’s kind of weird, but that’s how github works. So you always pull from upstream to get their changes, and push to your fork. --- class: center, middle # End version control – but github will come back later ;) ??? Ok, so that’s enough version control for now. But we’ll get back to githubs integration of third party services later. --- class: center, middle # General coding guidelines ??? Next, I want to talk about Python and some software engineering principles. But before we do that, I want to mention two famous quotes that provide great general guidelines for software development. --- class: middle Programs must be written for people to read, and only incidentally for machines to execute. .quote_author[Harold Abelson (wizard book)] ??? The first one is by Harold Abelson from the foreword of “structure and interpretation of computer programs” a classic in programming languages and compilers. [read] The gist is that the main point of code is to communicate ideas to your peers and to your future self. A similar sentiment is expressed in the statement that “code is read more often than it is written”. Take more time writing code, so that you and other can spend less time reading it. Don’t focus on what’s “easy for the computer” or “elegant”. Focus on what’s easy to understand for people. --- class: middle Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it? .quote_author[Brian Kernighan] ??? This one is from Brian Kernighan, who wrote the first book on C together with Dennis Richie. Kernighan is also the creator of awk and many other parts of unix, in particular the name. He says [read] This is another call for simplicity. Make code easy to understand. For yourself now to debug, for your future self to know what the hell you were thinking, and for others that might want to use this code in the future. Hopefully all the code you write will be read again. Otherwise, what’s the point? That might not be true for your assignments in most classes, but the point of the assignments it to practice for the real world. So I want to make sure that the code that you write in class is on the same standard that it needs to be out there on your job. Also, think of the poor course assistants. --- class: padding-top - Don’t be clever! - Make it readable! - Future you is the most likely person to try to understand your code. ??? So to summarize: [read] And there's one more trick to making your code readable and understandable. Don't write code. The more you write, the more you need to read. If you can avoid writing code, do it! If you can get a 10% speedup by making your code three times as long, usually it's not worth it. -- - Avoid writing code. --- class: center, middle # Python basics ??? So now I want to go over some Python basics. And don’t worries, we won’t go over syntax or the standard library. --- class: spacious # Why Python? - General purpose language - Great libraries - Easy to learn / use - Contenders: R (Scala? Julia?) ??? First, a short defense on why I’m teaching this class in Python. Python is a general purpose programming language, unlike matlab or R, so you can do anything with it. It is very powerful, mostly because there are so many libraries for python that you can do basically anything with just a couple of lines. Python is arguably easy to learn and easy to use, and it allows for a lot of interactivity. The only real contender in the data science space that I can think of is R, which is also a good option, but well, I’m not an R guy. Much of this course could be taught in R instead, though the software development tooling is a bit worse (but other things are better). You might have better chances with Python in industry jobs. There’s also Scala, but I’d argue that’s way too complicated and doesn’t have the right tools for the kind of data analysis and machine learning we want to do in this course. --- # The two language problem Python is sloooow… - Numpy: C - Scipy: C, fortran - Pandas: Cython, Python - Scikit-learn: Cython, Python - CPython: C ??? So there’s one thing that I really don’t like about Python. Any idea what that is? Python is slooow. Like really slow. So you know all these great libraries for Python for data science, like numpy, scipy, pandas and scikit-learn. Do you know what language they are written in? Numpy is written in C, Scipy is written in C and Fortran, pandas and scikit-learn are written in Cython and Python. And Cpython, the interpreter we use, is written in … C obivously That creates a bit of a divide between the users, who write python, and the developers, who write C and Cython. I have to admit, I don’t write a lot of Cython myself, mostly Python… but that’s not great. So you need to be aware that if you actually want to implement new algorithms, and you can’t express them with pandas and numpy, you might need to learn cython. For this course, this won’t really be a problem, though. We’ll stay firmly on the Python side. --- # Python 2 vs Python 3 - “current” : 2.7, 3.4, 3.5, 3.6, 3.7 ??? There’s another thing that you could call the two language problem, it’s python 2 vs python 3. The last version of python 2 is python 2.7, and really no-one should be using anything earlier. The commonly used versions of python 3 are 3.4 and 3.5, 3.6 and 3.7. There is really no reason to use python 2 any more. Unless you already wrote lots of code earlier. If you’re at a company it might not be easy to make the transition, and that’s why python 2 is still around. So the important part are the changes. Anyone know what changed? -- Changes (that will bite you) - `print` - division - Iterators (range, zip, map, filter, dictionary keys, values, items) - Strings / unicode ??? The print statement was removed, now print is a function, so it need parenthesis. The most common and trivial change. Division was changed to produce floats, so if you devided 2 by 3, it was 2 before, and now it’s 2.5 Then, many things that returned lists now return iterators, which is more memory efficient, but means you can’t necessarily retrieve things by index any more. That’s true for range, which now behaves like xrange before, zip, which behaves like izip, map and filter. Also, dictionary keys, values and items are now iterables and not lists. If you tried to index any of those, you probably had a bug anyhow. And really the main thing that changed is strings. And they changed completely. In 2, there was a string type and a unicode type. Now there’s a string type, which is always unicode, and a bytes type that is the raw bytes and needs an encoding to interpret. The story is really a bit complicated, and I suggest you read up on it. If your standard environment is Python2, you should update it to Python3 today. --- class: spacious # Python 2 && Python 3 - `from __future__ import print_function` - Six – tools for making 2 and 3 compatible code - 2to3 – convert python2 code to python3 code ??? If you write a library or code that you want to have reused, I suggest writing code that is compatible with both python 3 and python 2. Hopefully soon we can write Python3 only. For the first assignment I’ll make you do that, for later assignments the code only needs to run in 3.4 or newer. Generally it’s easy for code to run on both. You can just always use parenthesis on print, it will have no effect in python2. Or you can import features, like float division from the future. ` __future__` is a module that exists in python2 and python3 and that allows you to use certain python3 feature in python 2. Some cases are not covered, though, and the `six` package helps out in these cases. It provides some common names between python2 and python3. If you want to convert a codebase from python2 to python3, there’s an automatic converter called 2to3, which can do that for you. The next thing I want to talk about is managing python packages and environments. --- class: spacious # Python ... Package management: - don't use system python! - use Virtual environments - understand pip (and wheels) - probably use Conda (and anaconda or conda-forge) ??? Package management is really important if you want to become a serious python user. Unfortunately, it’s a bit tricky, partly due to the two language problem, which means packages have dependencies that are not in python. First of, you should be aware of the environment you are using. Usually it’s a good idea to work with virtual environments, in which you can control what software is installed in what version. If you’re on OS X or linux, your system will com with some python, but you don’t really want to mess with that. Create your own environments, and are aware of which environment you are using at any moment. The standard python way to install packages is pip, which is part of the setuptools package. Pip allows you to install all python packages in the pipy repository, which is basically all of them. -- ??? Until not so long ago, pip needed to compile all C code locally on your machine, which was pretty slow and complicated. Now, there are binary distributions, called wheels, which mean no compilation for most packages! If you’re compiling something when you’re installing, you’re probably doing it wrong. The issue with pip is that it only works for python packages, and some of our packages rely on linear algebra packages like blas and lapack, and you need to install them some other way. A really easy work-around for that is using a different package manager, called conda. It was created by a company called Anaconda (used to be continuum IO) and they ship a bundle called anaconda, which installs basically all the important packages. I recommend you use that for the course. Conda can be used with different source repositories. By default, it uses the anaconda one that is managed by the company. There’s also an open repository that is managed by the community that’s called conda-forge. In practice I use both conda and pip. --- class: some-space # Pip and conda and upgrades - Pip upgrade works on dependencies (unless you do -no-dep) - pip has no dependency resolution! - conda has dependency resolution - Use conda environments! - upgrading a conda package with pip (or vice versa) will break stuff! ??? Oh and one word of warning: if you do pip upgrade somepackage, it will also update all the dependencies. That is often not what you want, in particular if you are using it in a conda environment or if you installed a particular version of numpy or scipy that you don’t want upgraded. An imporatant thing to keep in mind about pip is that it has no dependency resolution, which means it will install the dependencies for any package you install, but it won't care about all the packages you installed before. So whenever you're using pip to install something, it could potentially break an already installed package. Conda on the other hand has a dependency resolution mechanism, which means it'll ensure that all the packages that you installed are compatible with each other. Sometimes there are conflicts between packages, though, which might prevent you from installing certain combinations. The solution here is to make liberal use of conda environments. If you need to work on a specific project, you should have a conda environment for that project ant it's requirements. Conda environments are really very useful and easy to use. Finally, don't try to upgrade a package with pip if it was installed with pip or the other way around. So if you mix conda and pip, make sure you check which one you used before upgrading. I recommend to use conda whenever possible. --- # Environments and Jupyter Kernels .smaller[ - Environment != kernels - Use nb_conda_kernels or add environment kernels manually: .smallest[ ```bash source activate myenv python -m ipykernel install --user --name myenv --display-name "Python (myenv)" source activate other-env python -m ipykernel install --user --name other-env --display-name "Python (other-env)" ``` ] - Even with `nb_conda_kernels`: need to install `ipykernel` package. ] .left-column[ ![:scale 100%](images/kernel_other_env.png) ] .right-column[ ![:scale 100%](images/kernel_other_env2.png) ] ??? If you're using conda environments, you will want to use them in your jupyter notebooks. However, jupyter is not immediately aware of your environments. Jupyter runtime environments are defined by kernels, which can be python environments, or different programming languages. You need to make sure that jupyter is aware of your environments to use them as a kernel. One way is to manually add them by using this command here which invokes `ipykernel install`. That works with any kind of python environment. For conda environments specifically, you can also install the `nb_conda_kernels` package, which will automatically create kernels for all environments that contain the `ipykernel` package. If you do either of them, you'll get a choice of which kernel you want to use for a notebook. That's a great way to use different versions of python, like 2 and 3, or different versions of scikit-learn or matplotlib or anything else. There is a bit more tooling around python that I want to talk about next. --- class: spacious # Dynamically typed, interpreted - Invalid syntax lying around - Code is less self-documenting ??? One of the reasons Python is so easy to learn and use is because it’s a dynamically typed languages. So who of you have worked with statically typed languages like C, C++, Java or Scala? It’s often a bit cumbersome that you have to declare the type of everything, but it provides some safety nets. For example you know that if the code compiles, the syntax is correct everywhere.  Mabye crash your machine, but whatever. Also, arguably, dynamically typed code is less self-documenting. If I write a function without documentation, it’s very hard for you to guess what I expect the input types to be. There’s now type annotations for Python, which is great, but they are not supported in Python2 and are not adopted everywhere yet. So how can we get back our safety nets? --- class: spacious # Editors - Flake8 / pyflake - Scripted / weak typing: Have a syntax checker! - write pep8 (according to the standard, not the tool) - use autopep8 if you have code lying around ??? One of the simplest fixes is to have a syntax checker in your editor. Whatever editor you’re using, make sure you have something like flake8 or pyflake installed that will tell you if you have obvious errors. These will also tell you if you have unused imports, undeclared variables or unused variables. All that helps you to immediately fix problems, and not wait until you run your program. I also recommend having a style checker. Flake8 also enforces pep8, which is the python style guide. You should write pep8 compatible code. It will make it easier for others to read your code, and once you’re used to it, it’ll make it easier for you to read other’s code. If you want to convert code to be pep8 compatible, check out the autopep8 package. The pep8 tool is very strict these days, and I don't heed all the warnings. There is a configuration file you can use to silence the more obnoxious ones. When I say you should write pep9, I mean you should write according to the standard, not the tool. The first guideline of pep8 is to use your own judgment and not blindly follow the guide. --- class: middle # Questions ?


| Package | com.developmentarc.core.services.requests |
| Interface | public interface IRequest extends flash.events.IEventDispatcher |
| Implementors | AbstractRequest |
The ITask interface allows the implemented class to be treated as a Request object allowing for it to be used through DevelopmentArc's service layer via the RequestDelegate.
A mock API is also build-in allowing for a service's result to be mocked up in the case a service is not yet completed.
See also
| Property | Defined by | ||
|---|---|---|---|
| dispatcherClass : Class [read-only]
Class reference to the dispatcher class used to dispatch this request.
| IRequest | ||
| mockClass : Class [read-only]
Class refernce to a IMockDispatcher used to mock up data to imitate a real service request
| IRequest | ||
| mode : String [read-only]
The current mode the dispatcher is in; mock or live.
| IRequest | ||
| params : Object [read-only]
Object storing parameters used in this requests.
| IRequest | ||
| parserClass : Class [read-only]
Class reference to the parser class used to parse this request's data
| IRequest | ||
| phase : String [read-only]
Defines the current phase this request is in.
| IRequest | ||
| source : String [read-only]
Source of the request, used with the uri to make up a specific address.
| IRequest | ||
| type : String [read-only]
Property supply's the type of request
| IRequest | ||
| uri : String [read-only]
Root address of the request.
| IRequest |
| Method | Defined by | ||
|---|---|---|---|
|
cancel():void
Marks a request has been canceled
| IRequest | ||
|
complete():void
Marks a request has completed its parsing and has saved it's data
| IRequest | ||
|
create():void
Marks request has been created
| IRequest | ||
|
dispatch():void
Marks a request has been dispatched via the dispatcher
| IRequest | ||
|
error(originalError:Error):void
Marks a request has errored during parsing of the result raw data
| IRequest | ||
|
failure(originalEvent:Event):void
Marks a request has errored during the dispatching of the request.
| IRequest | ||
|
parsing():void
Marks a request's data is being parsed.
| IRequest | ||
|
returned():void
Marks a request has returned from the dispatcher successfully
| IRequest | ||
|
saveData(data:*):void
Method is called when data has been parsed and needs to be saved.
| IRequest | ||
|
start():void
Starts request.
| IRequest | ||
|
stop():void
Stops request.
| IRequest |
| dispatcherClass | property |
dispatcherClass:Class
[read-only]Class reference to the dispatcher class used to dispatch this request.
Implementation public function get dispatcherClass():Class
| mockClass | property |
mockClass:Class
[read-only]Class refernce to a IMockDispatcher used to mock up data to imitate a real service request
Implementation public function get mockClass():Class
| mode | property |
mode:String
[read-only]The current mode the dispatcher is in; mock or live.
Implementation public function get mode():String
| params | property |
params:Object
[read-only]Object storing parameters used in this requests.
Implementation public function get params():Object
| parserClass | property |
parserClass:Class
[read-only]Class reference to the parser class used to parse this request's data
Implementation public function get parserClass():Class
| phase | property |
phase:String
[read-only]Defines the current phase this request is in.
Implementation public function get phase():String
| source | property |
source:String
[read-only]Source of the request, used with the uri to make up a specific address.
Implementation public function get source():String
| type | property |
type:String
[read-only]Property supply's the type of request
Implementation public function get type():String
| uri | property |
uri:String
[read-only]Root address of the request.
Implementation public function get uri():String
| cancel | () | method |
public function cancel():void
Marks a request has been canceled
| complete | () | method |
public function complete():void
Marks a request has completed its parsing and has saved it's data
| create | () | method |
public function create():void
Marks request has been created
| dispatch | () | method |
public function dispatch():void
Marks a request has been dispatched via the dispatcher
| error | () | method |
public function error(originalError:Error):void
Marks a request has errored during parsing of the result raw data
ParametersoriginalError:Error |
| failure | () | method |
public function failure(originalEvent:Event):void
Marks a request has errored during the dispatching of the request.
ParametersoriginalEvent:Event |
| parsing | () | method |
public function parsing():void
Marks a request's data is being parsed.
| returned | () | method |
public function returned():void
Marks a request has returned from the dispatcher successfully
| saveData | () | method |
public function saveData(data:*):void
Method is called when data has been parsed and needs to be saved. It's up to the request to save the data in the appropriate location.
Parametersdata:* |
| start | () | method |
public function start():void
Starts request.
| stop | () | method |
public function stop():void
Stops request.


CSS
freeCodeCamp
DevTools
CodePen
Head to https://kahoot.it
Check the Slack channel for the game pin
NounsAdjectivesVerbs
Our HTML dictates what content will be on the page. It provides our basic structure
Our CSS describes how that content should look, how it should be laid out, and what styles it should have
And our Javascript brings that content to life - it allows the user to interact with the content, providing a dynamic experience and determining the behaviour of the page
Similarly to how CSS is executed within style tags, we can use script tags for Javascript.
Like so:
Normally, however, an HTML document will contain a script tag with a src attribute, which will provide the HTML with a link to a separate Javascript file.
A header element
Open Google in your web browsers
Head to www.freeCodeCamp.org
For our purpose, a function can be thought of as a tiny program
At the most basic level, a function is something that can be called, and will return to us a value.
A function can also take arguments, or parameters.
A function that does not take any arguments:
This is how we declare a function:
And this is how we call, or invoke a function:
Once more, here’s how we declare a function (think of this as how you create a function, and define what it does):
And how we invoke it:
Head to https://repl.it/
Let's do this challenge together
Continue working on freeCodeCamp 'Basic JavaScript' 🚀
If you finish that (very long!) section, have a go at 'Basic Data Structures' and 'Basic Algorithm Scripting'


--- layout: post title: What is Domain-Driven Design? date: 2007-03-28 01:36:58.000000000 -06:00 type: post published: true status: publish categories: - Learning DDD tags: [] meta: _gcid: '16' _edit_last: '3110' _wp_page_template: default _bitly_trim: http://dddcommunity.org/?p=12 _intro_custom_banner: a:1:{s:3:"url";s:0:"";} _intro_text: default _custom_background: a:5:{s:3:"url";s:0:"";s:16:"background-color";s:0:"";s:17:"background-repeat";s:6:"repeat";s:21:"background-attachment";s:6:"scroll";s:19:"background-position";s:8:"left top";} _dependencies: s:6:"a:0:{}"; U_S_C_message: '' author: login: Vladimir Gitlevich email<EMAIL_ADDRESS>display_name: Vladimir Gitlevich first_name: Vladimir Gitlevich last_name: '' ---
Domain-driven design (DDD) is an approach to developing software for complex needs by deeply connecting the implementation to an evolving model of the core business concepts.
Its premise is:
The premise is simple, but pulling it off in the messy real world is hard. It calls for new skills and discipline, and a systematic approach.
Domain-driven design is not a technology or a methodology. DDD provides a structure of practices and terminology for making design decisions that focus and accelerate software projects dealing with complicated domains.
of course many things can put a project off course, bureaucracy, unclear objectives, lack of resources, to name a few, but it is the approach to design that largely determines how complex software can become. When complexity gets out of hand, the software can no longer be understood well enough to be easily changed or extended. By contrast, a good design can make opportunities out of those complex features.
Some of these design factors are technological, and a great deal of effort has gone into the design of networks, databases, and other technical dimension of software. Books have been written about how to solve these problems. Developers have cultivated their skills.
Yet the most significant complexity of many applications is not technical. It is in the domain itself, the activity or business of the user. When this domain complexity is not dealt with in the design, it won’t matter that the infrastructural technology is well-conceived. A successful design must systematically deal with this central aspect of the software.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/transfinite.20induction.html ---
Just for curiosity, is this a thing in Lean?
https://gitter.im/leanprover_public/Lobby?at=5a4a3b7a232e79134db2c204
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Experience Summary:
• Experience in J2EE Software Development Life Cycle of Enterprise level Web Applications utilizing Java, J2EE, JSP, Servlet, AJAX, JDBC and REST
• Experience in Front-End UI technologies: AngularJS, HTML, JavaScript/Typescript, BootStrap, JQuery
• Experience in Spring MVC and RDBMS systems like Oracle, MYSQL, PostgreSQL
• Developed Unit Testing Framework for AngularJS Applications using Karma, Mocha, Chai, Typescript
• Developed Web Automation Testing Framework using Selenium WebDriver, Java and Jsoup
Interned with NetApp (Watham,MA) as part of the OnCommmand Unified Manager Product Team for 8 months(May-December 2017).
Worked as a Full Time Software Engineer for almost 2 year at MetricStream Inc, Bangalore
Academic Summary:
Graduated from the Master's Program(MS) in Computer Science from University of Massachusetts Lowell in December 2017.
Coursework: Machine Learning, Artificial Intelligence, Data Mining, Internet of Things, Algorithms, Mobile Robots
Completed Bachelor of Technology(B.Tech) in Information Technology from National Institute of Technology Karnataka(NITK) , India
Technical Skills :
• Languages: Java, C/C++, Python, JavaScript/Typescript, Perl, PHP
• Web Framework: J2EE (Servlets, JavaBeans, JSP), Spring MVC, MEAN Stack, Drupal/PHP, REST
• Web Technologies: AngularJS, Node.js, ExpressJS, Webpack, XML/HTML, AJAX, JQuery, BootStrap
• Database: Oracle 11G, MySQL, PL-SQL, MongoDB
• Testing Tools: JUnit, Selenium, Jasmine, Karma, Mocha, Sinon, Chai
• Development Tools: SVN, GIT, Perforce, Apache Tomcat, WebSphere, Linux, Shell Scripting
• Machine Learning and IOT: Amazon AWS, MQTT, Raspberry Pi, scikit-learn, MATLAB, TensorFlow
Currently I am looking for Full Time Opportunities starting from January 2018.
Please feel free to contact me at<EMAIL_ADDRESS>or<PHONE_NUMBER>.
Worked as a Software Engineering Intern in the OnCommand Unified Manager(OCUM) Team, a NetApp product used to monitor health of NetApp Storage Systems running ONTAP Operating System.
Developed Enhancements for the Components of NWFJS UI Library using AngularJS and Typescript.
Built Unit Testing Framework for the AngularJS based User Interface of OnCommand Unified Manager(OCUM) using Technologies like Mocha, Karma, Chai, Sinon and Webpack.
Fixed Security Issues of the client facing NetApp Workflow Automation Store (built on PHP)
Worked on updating BlackDuck-Codecenter with the source code files and details of the technological components used in the UI Application
Worked on the 508 Accessibility Compliance of the University Official Website
Assisted in the migration and maintenance of the Website
Worked on Tridion Content Management System.
Debugged and Fixed issues present in the Web Application.
Performed Cross-Browser Testing and Functional Testing of the Web Application.
Worked on the Quality Assurance of the Web Application.
Developed Software components for GRC Platform M7 which provides Risk Management, Regulatory Compliance, Vendor Governance and Quality Management to Large Enterprises.
Built Servlets, Web pages and SQL Queries for the GRC Web Application using tools: Oracle SQL Developer, Eclipse IDE. Wrote over 10,000 lines of Quality Java Code for the Application.
Designed and Built Automation Testing Framework using Technologies: Selenium WebDriver, JExcel, JSoup, TestNG and Java. Performed Unit Testing using Junit and worked on Black Box Testing.
Decreased Test Script preparation time for Web Forms/Workflows from average of 1.5 week to 3 days.
Contributed to development of Internal Tools: Customization of Bugzilla-Bug Reporting Tool (using Perl), contributed to development of Performance Testing Tool based on Apache JMeter.
Designed and implemented a Web Application using CMS framework -Drupal with PHP
Maintained and Debugged issues in ERP (Enterprise Resource Planning) solution using .Net and C++.
Trained Neural Network Models to predict occupancy of a room based on sensor readings like Temperature,Relative Humidity, Light, CO2, Humidity Ratio
Developed a Lock that on Unlocking, uploaded captured Images/Timestamps into Amazon DynamoDB.
The Objective of the project is to Transfer file securely from Client to Server using AES-128, Diffie-Hellman Key Exchange, SSL Certificates.
It is an Artificial Intelligence Project.Designed an AI agent which using Q-Learning learned about the user's Interest.The
user has to login to an Dashboard App using his/her Facebook or Google account.The AI agent fetches
the details about the user from those social network sites.Once the user is registered in the
app the user activity is fetched to give user the content online which the user would be most
interested in.
Technologies Used : Node.js,Angular.js,Facebook
APIs,Google APIs,MongoDB
Built using Android Studio, Google Map APIs, Android Java and Appium for Testing
Converted an Microsoft Access Database Application into in an Apple FileMaker Solution. Employee Training Management System
consists of Employee profile Tracking,features to Recognize if an certain employee requires a
Training based on the role, he/she is assigned.The system is used to conducted Exams and issue
Certificates.
Tools used in Project : FileMaker Pro 13,Microsoft Access.
Collected, categorized and performed visualization on Online News Data on a 3-D Geospatial Map.


Exporting a Page
How to export a page which will be saved as a page template which can then be imported into any DNN site.
- Navigate to the required page. See "Viewing Any Page"
- On the ControlBar, hover over the Edit Pages menu option and then select Export Page
- At Folder, select a folder of the site's Digital Asset Management module (located on the Admin > File Management page) where the exported page will be stored.
- In the Template Name text box, the name of the exported page is displayed. You can either use this as the name of the page template or change it to a new name.
- In the Description text box, enter a description of the page you are exporting. This description is exported with the page template. Typically the description provides a brief overview of the page and (if included) it's content.
- Optional. At Include Content?, to include module content - OR - to add the modules without any content.
- Click the Export button.
- The path where the page template has been created is now displayed.


{% include head.html %}
Versatile and agile engineer, with experience building web applications in Ruby, Rails, and Python. Skilled with frontend, backend, and infrastructure development. Preference for full- stack development, opportunities to learn new technologies and problem domains, and flexible and innovative teams with an emphasis on agile methods though not necessarily Agile dogma.
Joined the core payments logic team at a large payments processor to help with continued growth and international expansion. Wrote Ruby, Go, and Scala for major new partner integrations and helped design systems rearchitecture for international growth. Helped maintain, operate, and refactor critical payments infrastructure handling all volume.
First employee for a health insurance startup, helped grow the company to 30+ employees and 10k+ concurrent users. Developed backend in Ruby on Rails and frontend using Backbone.js and React.js. Wrote specialized Python system for machine-learning tasks. Took charge of DevOps efforts and used Chef to build a scaling EC2 cluster to handle high- complexity high-reliability worker queues.
Took over all DevOps tasks. Revamped Chef suite, rebuilt staging infrastructure, built out MySQL replication with high-availability and instant failover capabilities, led security and performance development efforts, provided mentoring in TDD and agile methodologies.
Performed product and feature development for large-scale e-commerce RoR applications with complex dynamic pricing engine and automated distributor network. Transitioned to DevOps team in July 2011, with an emphasis on Chef for systems automation. Led projects to upgrade five large-scale applications and ~80 backend scripts to Rails 3, and Ruby 1.9.
Led project team writing RoR department management applications. Responsible for interviewing, selecting, and training new team members, assisting with project management and release scheduling, and full-time development.
Supervised other student employees in university tech support group. Responsible for managing all tech support for approximately 500 students, both in communicating with students, coordinating other technicians and in directly performing repairs.
Ruby, Javascript, Python, Scala, Go, C++, Rails, Jquery, Backbone.js, Selenium, Elasticsearch, scikit-learn, Sinatra
Chef, Puppet, Capistrano
AWS, Heroku, Rackspace, Colo
Maintainer for Improved Rack/Throttle. Contributor to Rails, Chef, and others.
Additional coursework equivalent to a minor in Computer Science (no formal minor available)
Donut Locator is an open source node/ember app that lets users find donuts within a defined radius from their home.
DEUG is a local monthly meetup in Springfield where we share all the latest tips and tricks for dat donut lifestyle. I organize the group, and typically eat most of the donuts.
Awarded for stopping a nuclear meltdown, even though I also started it.
Honored by Duff Beer for being an outstanding customer several years straight. Qualifications included most beer consumed at a bar, most beer purchased, and most beer ralphed.
Specifically this prestigious awarded twice for stopping a robber with my belly.
Organized fund drives and participated in fundraising events for the benefit of families in third world countries without proper access to malt beverages.
Founding member of the local nuclear workers labor union.


--- layout: default title: Youth Strings permalink: "/youth-strings/" --- {% include youth-strings-header.html %}
The Youth Strings is our newest ensemble that started in the spring of 2023. This ensemble is for students aged 5 to 18, and we host two separate groups: a beginner group and an intermediate group. Students will learn to play with others, making beautiful music together, as well as participate in Master Classes, sectional and leadership opportunities. We will tackle music from a variety of genres, including traditional baroque, popular and movie music, as well as fiddle/folk tunes.
The Youth Strings ensemble is directed by Madeline Bailey and Karen Dees.


Next, we deﬁne the guiding-center transform and then we transform the Vlasov equation from the particle coordinates (x,v) to the guiding-center coordinates, i.e., express the gradient operators ∂∕∂x and ∂∕∂v in terms of the guiding-center coordinates.
In a magnetic ﬁeld, given a particle location and velocity (x,v), we know how to calculate its guiding-center location X, i.e.,
|
| (17) |
where e∥ = B0∕B0, Ω = qB0∕m, B0 = B0(x) is the equilibrium (macroscopic) magnetic ﬁeld at the particle position. We will consider Eq. (17) as a transform and call it guiding-center transform[1]. Note that the transform (17) involves both position and velocity of particles.
For later use, deﬁne ρ ≡−v × e∥∕Ω, which is the vector gyro-radius pointing from the the guiding-center to the particle position.
Given (x,v), it is straightforward to obtain X by using Eq. (17). On the other hand, the inverse transform, i.e., given (X,v), to ﬁnd x, which is in principle not easy because Ω and e∥ depend on x, which usually requires solving for the root of a nonlinear equation. Numerically, one can use
|
| (18) |
as an iteration scheme to compute x, with the initial guess chosen as x0 = X. The equilibrium magnetic ﬁeld we will consider has spatial scale length much larger than the thermal gyro radius ρ. In this case the diﬀerence between the values of e∥(x)∕Ω(x) and e∥(X)∕Ω(X) is small and thus can be neglected. Then the inverse guiding-center transform can be written as
|
| (19) |
which can also be considered as using the iterative scheme (18) to computer x with initial guess of x being X and stopping at the ﬁrst iteration. [The diﬀerence between equilibrium ﬁeld values evaluated at X and x is usually neglected in gyrokinetic theory. Therefore it does not matter whether the above e∥∕Ω is evaluated at x or X. What matters is where the perturbed ﬁelds are evaluated: at x or at X. The values of perturbed ﬁelds at x or at X are diﬀerent and this is called the ﬁnite Larmor radius (FLR) eﬀect, which is almost all that the gyrokinetic theory is about.]
The inverse guiding-center transformation (19) needs to be performed numerically in gyrokinetic PIC simulations when we deposit markers to grids or when we calculate the gyro-averaged ﬁeld to be used in pushing guiding-centers.
The guiding-center transformations (17) and (19) involve the particle velocity v. It is the cross product between v and e∥(x) or e∥(X) that is actually used. Therefore, only the perpendicular velocity (which is deﬁned by v⊥ = v − v ⋅ e∥) enters the transform. A natural choice of coordinates for the perpendicular velocity is (v⊥,α), where v⊥ = |v⊥| and α is the azimuthal angle of the perpendicular velocity in the local perpendicular plane.
The parallel direction is fully determined by B0(x), but there are degrees of freedom in choosing one of the two perpendicular basis vectors. In order to make the azimuthal angle α fully deﬁned, we need to choose a way to deﬁne one of the two perpendicular directions. In GEM simulations, one of the perpendicular direction is chosen as the direction perpendicular to the magnetic surface, which is fully determined at each spatial point. (We need to deﬁne the perpendicular direction at each spatial location to make ∂α∕∂x|v deﬁned, which is needed in the Vlasov diﬀerential operators. However, it seems that terms related to ∂α∕∂x|v are ﬁnally dropped due to that they are of higher order**check.)
In the following, α will be called the “gyro-angle” . [Note that, in the guiding-center coordinates (X,v∥,v⊥,α), α is a velocity coordinate rather than a spatial coordinate. When transformed back to particle coordinates, α is both a velocity coordinate and a spatial coordinate. Consider a series of points in terms of guiding-center coordinates (X,v∥,v⊥,α) with (X,v∥,v⊥) ﬁxed but with α changing. Using the inverse guiding-center transform (19), we know that the above points form a gyro-ring in space, i.e., α inﬂuences both particle velocity and location.]
The gyro-angle is an important variable we will stick to because we need to directly perform averaging over this variable (with X ﬁxed) in deriving the gyrokinetic equation. We have more than one choice for the remaining velocity coordinates , such as (v,v∥), or (v,v⊥), or (v∥,v⊥). In Frieman-Chen’s paper, the velocity coordinates other than α are chosen to be (𝜀,μ) deﬁned by
|
| (20) |
and
|
| (21) |
where Φ0(x) is the equilibrium (macroscopic) electrical potential. Choosing μ as one of the phase space coordinates is nontrivial because it turns out a constant of motion. And this choice is important in sucessfully getting the ﬁnal gyrokinetic equation (I need to think about this).
Note that (𝜀,μ,α) is not suﬃcient in uniquely determining a velocity vector. An additional parameter σ = sign(v∥) is needed to determine the sign of v∥ = v ⋅e∥. In the following, the dependence of the distribution function on σ is often not explicitly shown in the variable list (i.e., σ is hidden/suppressed), which, however, does not mean that the distribution function is independent of σ.
Another frequently used velocity coordinates are (μ,v∥,α). In the following, I will derive the gyrokinetic equation in (𝜀,μ,α) coordinates. After that, I transform it to (μ,v∥,α) coordinates.
One important thing to note about the above velocity coordinates is that they are deﬁned relative to the local magnetic ﬁeld. If the ﬁeld itself is spatially varying (such as in tokamaks), the above velocity coordinates are also spatially varying for a ﬁxed velocity v. Speciﬁcally, the following derivatives are nonzero:
|
| (22) |
The transform from particle variables (x,v) to guiding-center variables (X,𝜀,μ,α,σ) is given by
|
| (23) |
As mentioned above, the dependence of the distribution function on σ will not be explicitly indicated in the following.
Denote the particle distribution function expressed in particle coordinates (x,v) by fp, and the same distribution expressed in the guiding-center variables (X,𝜀,μ,α) by fg. Then
|
| (24) |
where (x,v) and (X,𝜀,μ,α) are related to each other by the guiding-center transform (19). Equation (24) along the guiding-center transform can be considered as the deﬁnition of fg. (If fg is independent of α, then, using the inverse guiding-center transform, we know that fp is constant along the spatial gyro-ring with velocity direction changing according to the gyro-phase.)
As is conventionally adopted in multi-variables calculus, both fp and fg are often denoted by the same symbol, say f. Which set of independent variables (particle variables or guiding-center variables) are actually assumed is inferred from the context. This is one of the subtle things needed to note for gyrokinetic theory in particular and for multi-variables calculus in general. (Sometimes, it may be better to use subscript notation on f to identify which coordinates are assumed. One example where this distinguishing is important is encountered when we try to express the diamagnetic ﬂow in terms of fg, which is discussed in Appendix B.)
In practice, fg is often called the guiding-center distribution function whereas fp is called the particle distribution function. However, they are actually the same distribution function expressed in diﬀerent variables. The name “guiding-center distribution function” is misleading because it may imply that we can count the number of guiding-centers to obtain this distribution function but this implication is wrong.
Using the chain-rule, the spatial gradient ∂fp∕∂x is written
|
| (25) |
From the deﬁnition of X, Eq. (17), we obtain
|
| (26) |
where I is the unit dyad. From the deﬁnition of 𝜀, we obtain
|
| (27) |
where E0 = −∂Φ0∕∂x. Using the above results, equation (25) is written as
|
| (28) |
As mentioned above, the partial derivative ∂∕∂x is taken by holding v constant. Since B0 is spatially varying, v⊥ is spatially varying when holding v constant. Therefore and are generally nonzero. The explicit expressions of these two derivatives are needed later in the derivation of the gyrokinetic equation and is discussed in Appendix F. For notation ease, deﬁne
|
| (29) |
and
|
| (30) |
then expression (28) is written as
|
| (31) |
Next, consider the form of the velocity gradient ∂f∕∂v in terms of the guiding-center variables. Using the chain rule, ∂f∕∂v is written
|
| (32) |
From the deﬁnition of X, we obtain
|
| (34) |
From the deﬁnition of μ, we obtain
|
| (35) |
From the deﬁnition of α, we obtain
|
| (36) |
where eα is deﬁned by
|
| (37) |
Using the above results, expression (32) is written
|
| (38) |
In terms of the guiding-center variables, the time partial derivative ∂fp∕∂t appearing in Vlasov equation is written as
|
| (39) |
where V = (𝜀,μ,α). Here ∂X∕∂t and ∂V∕∂t are not necessarily zero because the equilibrium quantities involved in the deﬁnition of the guiding-center transformation are in general time dependent. This time dependence is assumed to be very slow in the gyrokinetic ordering discussed later. In the following, ∂X∕∂t and ∂V∕∂t will be dropped, i.e.,
|
| (40) |
Using the above results, the Vlasov equation in guiding-center coordinates is written
Using tensor identity a ⋅ I × b = a × b, equation (41) is written as This is the Vlasov equation in guiding-center coordinates.


and an image with custom html attributes and a caption
named paragraph
named block
#not a comment because there's no space after the hashtag
A table of contents can be rendered anywhere in the document by using
#+TOC: headlines $n
Where $n
is the max headline lvl that will be included. You can use headlines 0
to include all headlines.


Leftover Baja Fresh in the breakroom... it was a good day to not bring my lunch in.
2/12/2009, 1:04:43 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Leftover Baja Fresh in the breakroom... it was a good day to not bring my lunch in.
2/12/2009, 1:04:43 PM
Favs: 0
Retweets: 0
link


the and for {background margin with {border-style px;} #ffffff;} use patients this our that are her have opioid will treatment many px; {font-family font-size these would COVID access care double; emergency from not substance additional border-color border-width buprenorphine continue disorder distancing has health providers recovery solid; telehealth they which who without {font-style {font-weight Addict all any bold can care. challenges changes courier; due em; existing most new pandemic patient peer provide pt;} she social specialist their those via was while


This application is for you to find a doctor's appointment quickly and at your earliest convenience. This application is not intended for use if you have an Emergency. In the case of an emergency please call 911 or get to an Emergency Room.


Susan Granger's review of "ONE TRUE THING" (Universal Pictures)
With all that has been written about the feminist movement, it took Pulitzer Prize-winning Anna Quindlen to write an engrossing story that dramatizes the complex difference between our mother's generation and us, a confrontation between a woman whose expectations never extended beyond her home and her children and her husband's career, who viewed her life as an adjunct to those things, and her daughter, whom she raised not only to work but to expect the world. Renee Zellweger ("Jerry Maguire") plays an ambitious Manhattan journalist who is forced to move back home to help her middle-aged parents - Meryl Streep and William Hurt - through a cancer crisis. Not only does she discover who her parents really are - their strengths, their weaknesses - but the gutsy, gritty emotional journey she undertakes as a care-giver is a complicated rite-of-passage to her own maturity. Superbly adapted for the screen by Karen Croner and directed by Carl Franklin ("Devil in a Blue Dress"), the performances are dazzling, except for Tom E. Scott's bland younger brother character which is grossly underwritten. Renee Zellweger, in particular, is captivating; she is irresistible as an actress, while Meryl Streep is luminous, perceptive, and courageous. On the Granger Movie Gauge of 1 to 10, "One True Thing" is a wise, resolute 8. It's a remarkable, intimate film that reverberates with love for an unbroken generation of stay-at-home mothers who knew how to have fun within a limited arena and to love the life they made for the mselves.
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


In the past few years, a push for open reproducible research has led to a proliferation of community efforts for publishing raw research objects like datasets, software, methodologies, etc. These efforts underpin research outcomes much more explicitly accessible. However, the actual time and effort required to achieve this new form of scientific communication remains a key barrier to reproducibility. Furthermore, scientific experiments are becoming increasingly complex, and ensuring that research outcomes become understandable, interpretable, reusable and reproducible is still a challenge.
The goal of this workshop is to incentivise practical solutions and fundamental thinking to bridge the gap between existing scientific communication methods and the vision of an reproducible and accountable open science. Semantic Web technologies provide a promising means for achieving this goal, enabling more transparent and well-defined descriptions for all scientific objects required for this new form of science and communication. We are particularly interested in four kinds of contributions:
Topics for submissions include, but are not limited to:
| 09:00-09:10 | Introduction |
| Session 1: Extracting and Representing Semantics | |
| 09:10-09:50 | Keynote speaker: Carole Goble The Rhetoric of Research Objects (slides) |
| 09:50-10:10 | Gully Burns, Pradeep Dasigi and Ed Hovy. Extracting Evidence Fragments for Distant Supervision of Molecular Interactions (Slides) |
| 10:10-10:30 | Carlos Badenes-Olmedo, Jose Luis Redondo-Garcia and Oscar Corcho. An initial Analysis of Topic-based Similarity among Scientific Documents based on their Rhetorical Discourse Parts. (Slides) |
| 10:30-11:00 | Coffee break |
| Session 2: Semantic metadata | |
| 11:00-11:40 | Keynote speaker: Frank van Harmelen The end of the scientifc paper as we know it (in 4 easy steps) (slides) |
| 11:40-12:00 | Mihyun Jang, Tejal Patted, Yolanda Gil, Daniel Garijo, Varun Ratnakar, Jie Ji, Prince Wang, Aggie McMahon, Paul Thompson and Neda Jahanshad. Automatic Generation of Portions of Scientific Papers for Large, Multi-Institutional Collaborations Based on Semantic Metadata (slides). |
| 12:00-12:20 | Rafael S. Gonçalves, Martin J. O'Connor, Marcos Martínez-Romero, John Graybeal and Mark A. Musen. Metadata in the BioSample Online Repository are Impaired by Numerous Anomalies (slides). |
| 12:20-14:00 | Lunch |
| Session 3: Semantic Technologies for Science | |
| 14:00-14:20 | Sabbir Rashid, Katherine Chastain, Jeanette Stingone, Deborah McGuinness and Jim McCusker. The Semantic Data Dictionary Approach to Data Annotation and Integration (slides). |
| 14:20-14:40 | Vera G. Meister. Towards a Knowledge Graph for a Research Group with Focus on Qualitative Analysis of Scholarly Papers (slides) |
| 14:40-15:00 | Ali Khalili, Peter van Den Besselaar, Al Koudous Idrissou, Klaas Andries de Graaf and Frank van Harmelen. Semantically Mapping Science (SMS) Platform (slides). |
| 15:00-15:20 | Ensar Hadziselimovic, Kaniz Fatema, Harshvardhan J. Pandit and Dave Lewis. Linked Data Contracts to Support Data Protection and Data Ethics in the Sharing of Scientific Data (slides). |
| 15:20-16:00 | Coffee break |
| Session 4: Provenance and Scientific Experiments | |
| 16:00-16:20 | Joachim Van Herwegen, Ruben Taelman, Sarven Capadisli and Ruben Verborgh. Describing configurations of software experiments as Linked Data (slides). |
| 16:20-16:40 | Ben De Meester, Anastasia Dimou, Ruben Verborgh and Erik Mannens. Detailed Provenance Capture of Data Processing (slides) . |
| 16:40-17:20 | Keynote speaker: Silvio Peroni The open citations revolution (slides) |
Paper submission and reviewing for this workshop will be electronic via EasyChair. The papers should be written in English, following the Springer LNCS format, and be submitted in PDF on or before August 6, 2017. However, SemSci2017 explicitly welcomes alternative and enhanced submission formats, such as communicative online materials. Authors who are preparing such a submission should contact the workshop organizers in advance to make sure we can accommodate for them in the submission and review process. All deadlines are midnight Hawaii time.
The following types of contributions are welcome.
Papers presenting a tool will be reviewed based on potential impact of the tool for Open Semantic Science, usability, and documentation. Accepted papers will be published at the CEUR workshop series.
The following list of submissions participate in an open review process, i.e., both the submitted paper and reviews (if reviewers agree) will be made available online:
The proceedings for the workshop are avilable at http://ceur-ws.org/Vol-1931/


Agent Client Management
Use this service to:
- Register as a new agent
- Link to a new client
- Manage clients
Registering takes around 5 minutes.
Start nowBefore you start
You can also register as an Agent.
You can also sign in as an Client.
You cannot register for this service if you're in the UK illegally.


Hi, I'm Musa, I am a Full Stack Web Developer and strive to bring great content for to the Internet I work hard to bring great functionality and UX for you and customers in my web apps.


JOIN
Join ScholarLed
ScholarLed is a consortium of open access book publishers providing ways for small-scale, scholar-led open access presses to grow and flourish. Together we establish collaborative modes of working and open infrastructures that support the work of publishers like ourselves.
ScholarLed presses are run by scholars and engaged in supporting and building communities of practice and care.
- ScholarLed member presses have published at least one book and commit to making all their publications open access without embargo;
- Our books are freely accessible without the requirement for registration of any kind;
- We care about the quality of the work we publish, and develop protocols for reviewing our publications that support community, care and the highest standards of scholarly content;
- We are committed to supporting the knowledge commons;
- In our online and offline presence, we strive to provide clear information about our mission, ethos, people involved, ownership and governance models, production and review process, funding models, and any author-facing charges;
- We share our practices, experiences, and models with each other in the spirit of mutual support.
If you want to join us, drop us a note at<EMAIL_ADDRESS>with the name and website of your publishing house and a person we can contact. The ScholarLed board assesses applications on a running basis, but please be patient with us. Our recommended membership contribution is currently 50€ per year. This covers the basic running costs of our fledgling organisation, which is registered as a not-for-profit foundation in the Netherlands. If you want to know more about how we govern ourselves, have a look at our bylaws.


{{ $style := resources.Get "scss/devresume.scss" | resources.ExecuteAsTemplate "scss/devresume.scss" . | toCSS (dict "targetPath" "assets/css/devresume.css") | minify | fingerprint }}


twilio.rest.conversations.v1.configuration package¶
Submodules¶
twilio.rest.conversations.v1.configuration.webhook module¶
This code was generated by / _ _ _| _ _
(_)/(_)(_|/| |(/_ v1.0.0 / /
-
class
twilio.rest.conversations.v1.configuration.webhook.
WebhookContext
(version)[source]¶ Bases:
twilio.base.instance_context.InstanceContext
-
fetch
()[source]¶ Fetch the WebhookInstance
Returns: The fetched WebhookInstance Return type: twilio.rest.conversations.v1.configuration.webhook.WebhookInstance
-
update
(method=<object object>, filters=<object object>, pre_webhook_url=<object object>, post_webhook_url=<object object>, target=<object object>)[source]¶ Update the WebhookInstance
Parameters: - method (unicode) – The HTTP method to be used when sending a webhook request.
- filters (list[unicode]) – The list of webhook event triggers that are enabled for this Service.
- pre_webhook_url (unicode) – The absolute url the pre-event webhook request should be sent to.
- post_webhook_url (unicode) – The absolute url the post-event webhook request should be sent to.
- target (WebhookInstance.Target) – The routing target of the webhook.
Returns: The updated WebhookInstance
Return type: twilio.rest.conversations.v1.configuration.webhook.WebhookInstance
-
-
class
twilio.rest.conversations.v1.configuration.webhook.
WebhookInstance
(version, payload)[source]¶ Bases:
twilio.base.instance_resource.InstanceResource
-
account_sid
¶ Returns: The unique ID of the Account responsible for this conversation. Return type: unicode
-
fetch
()[source]¶ Fetch the WebhookInstance
Returns: The fetched WebhookInstance Return type: twilio.rest.conversations.v1.configuration.webhook.WebhookInstance
-
filters
¶ Returns: The list of webhook event triggers that are enabled for this Service. Return type: list[unicode]
-
method
¶ Returns: The HTTP method to be used when sending a webhook request. Return type: WebhookInstance.Method
-
post_webhook_url
¶ Returns: The absolute url the post-event webhook request should be sent to. Return type: unicode
-
pre_webhook_url
¶ Returns: The absolute url the pre-event webhook request should be sent to. Return type: unicode
-
target
¶ Returns: The routing target of the webhook. Return type: WebhookInstance.Target
-
update
(method=<object object>, filters=<object object>, pre_webhook_url=<object object>, post_webhook_url=<object object>, target=<object object>)[source]¶ Update the WebhookInstance
Parameters: - method (unicode) – The HTTP method to be used when sending a webhook request.
- filters (list[unicode]) – The list of webhook event triggers that are enabled for this Service.
- pre_webhook_url (unicode) – The absolute url the pre-event webhook request should be sent to.
- post_webhook_url (unicode) – The absolute url the post-event webhook request should be sent to.
- target (WebhookInstance.Target) – The routing target of the webhook.
Returns: The updated WebhookInstance
Return type: twilio.rest.conversations.v1.configuration.webhook.WebhookInstance
-
url
¶ Returns: An absolute URL for this webhook. Return type: unicode
-
-
class
twilio.rest.conversations.v1.configuration.webhook.
WebhookList
(version)[source]¶ Bases:
twilio.base.list_resource.ListResource
-
get
()[source]¶ Constructs a WebhookContext
Returns: twilio.rest.conversations.v1.configuration.webhook.WebhookContext Return type: twilio.rest.conversations.v1.configuration.webhook.WebhookContext
-
-
class
twilio.rest.conversations.v1.configuration.webhook.
WebhookPage
(version, response, solution)[source]¶ Bases:
twilio.base.page.Page
-
get_instance
(payload)[source]¶ Build an instance of WebhookInstance
Parameters: payload (dict) – Payload response from the API Returns: twilio.rest.conversations.v1.configuration.webhook.WebhookInstance Return type: twilio.rest.conversations.v1.configuration.webhook.WebhookInstance
-
Module contents¶
This code was generated by / _ _ _| _ _
(_)/(_)(_|/| |(/_ v1.0.0 / /
-
class
twilio.rest.conversations.v1.configuration.
ConfigurationContext
(version)[source]¶ Bases:
twilio.base.instance_context.InstanceContext
-
fetch
()[source]¶ Fetch the ConfigurationInstance
Returns: The fetched ConfigurationInstance Return type: twilio.rest.conversations.v1.configuration.ConfigurationInstance
-
update
(default_chat_service_sid=<object object>, default_messaging_service_sid=<object object>, default_inactive_timer=<object object>, default_closed_timer=<object object>)[source]¶ Update the ConfigurationInstance
Parameters: - default_chat_service_sid (unicode) – The SID of the default Conversation Service that every new conversation will be associated with.
- default_messaging_service_sid (unicode) – The SID of the default Messaging Service that every new conversation will be associated with.
- default_inactive_timer (unicode) – Default ISO8601 duration when conversation will be switched to inactive state.
- default_closed_timer (unicode) – Default ISO8601 duration when conversation will be switched to closed state.
Returns: The updated ConfigurationInstance
Return type: twilio.rest.conversations.v1.configuration.ConfigurationInstance
-
-
class
twilio.rest.conversations.v1.configuration.
ConfigurationInstance
(version, payload)[source]¶ Bases:
twilio.base.instance_resource.InstanceResource
-
account_sid
¶ Returns: The SID of the Account responsible for this configuration. Return type: unicode
-
default_chat_service_sid
¶ Returns: The SID of the default Conversation Service that every new conversation is associated with. Return type: unicode
-
default_closed_timer
¶ Returns: Default ISO8601 duration when conversation will be switched to closed state. Return type: unicode
-
default_inactive_timer
¶ Returns: Default ISO8601 duration when conversation will be switched to inactive state. Return type: unicode
-
default_messaging_service_sid
¶ Returns: The SID of the default Messaging Service that every new conversation is associated with. Return type: unicode
-
fetch
()[source]¶ Fetch the ConfigurationInstance
Returns: The fetched ConfigurationInstance Return type: twilio.rest.conversations.v1.configuration.ConfigurationInstance
-
links
¶ Returns: Absolute URLs to access the webhook and default service configurations. Return type: unicode
-
update
(default_chat_service_sid=<object object>, default_messaging_service_sid=<object object>, default_inactive_timer=<object object>, default_closed_timer=<object object>)[source]¶ Update the ConfigurationInstance
Parameters: - default_chat_service_sid (unicode) – The SID of the default Conversation Service that every new conversation will be associated with.
- default_messaging_service_sid (unicode) – The SID of the default Messaging Service that every new conversation will be associated with.
- default_inactive_timer (unicode) – Default ISO8601 duration when conversation will be switched to inactive state.
- default_closed_timer (unicode) – Default ISO8601 duration when conversation will be switched to closed state.
Returns: The updated ConfigurationInstance
Return type: twilio.rest.conversations.v1.configuration.ConfigurationInstance
-
url
¶ Returns: An absolute URL for this global configuration. Return type: unicode
-
-
class
twilio.rest.conversations.v1.configuration.
ConfigurationList
(version)[source]¶ Bases:
twilio.base.list_resource.ListResource
-
get
()[source]¶ Constructs a ConfigurationContext
Returns: twilio.rest.conversations.v1.configuration.ConfigurationContext Return type: twilio.rest.conversations.v1.configuration.ConfigurationContext
-
webhooks
¶ Access the webhooks
Returns: twilio.rest.conversations.v1.configuration.webhook.WebhookList Return type: twilio.rest.conversations.v1.configuration.webhook.WebhookList
-
-
class
twilio.rest.conversations.v1.configuration.
ConfigurationPage
(version, response, solution)[source]¶ Bases:
twilio.base.page.Page
-
get_instance
(payload)[source]¶ Build an instance of ConfigurationInstance
Parameters: payload (dict) – Payload response from the API Returns: twilio.rest.conversations.v1.configuration.ConfigurationInstance Return type: twilio.rest.conversations.v1.configuration.ConfigurationInstance
-


public abstract static class ViewDragHelper.Callback
extends java.lang.Object
on*
methods are invoked on siginficant events and several
accessor methods are expected to provide the ViewDragHelper with more information
about the state of the parent view upon request. The callback also makes decisions
governing the range and draggability of child views.| Constructor and Description |
|---|
ViewDragHelper.Callback() |
| Modifier and Type | Method and Description |
|---|---|
int |
clampViewPositionHorizontal(View child,
int left,
int dx)
Restrict the motion of the dragged child view along the horizontal axis.
|
int |
clampViewPositionVertical(View child,
int top,
int dy)
Restrict the motion of the dragged child view along the vertical axis.
|
int |
getOrderedChildIndex(int index)
Called to determine the Z-order of child views.
|
int |
getViewHorizontalDragRange(View child)
Return the magnitude of a draggable child view's horizontal range of motion in pixels.
|
int |
getViewVerticalDragRange(View child)
Return the magnitude of a draggable child view's vertical range of motion in pixels.
|
void |
onEdgeDragStarted(int edgeFlags,
int pointerId)
Called when the user has started a deliberate drag away from one
of the subscribed edges in the parent view while no child view is currently captured.
|
boolean |
onEdgeLock(int edgeFlags)
Called when the given edge may become locked.
|
void |
onEdgeTouched(int edgeFlags,
int pointerId)
Called when one of the subscribed edges in the parent view has been touched
by the user while no child view is currently captured.
|
void |
onViewCaptured(View capturedChild,
int activePointerId)
Called when a child view is captured for dragging or settling.
|
void |
onViewDragStateChanged(int state)
Called when the drag state changes.
|
void |
onViewPositionChanged(View changedView,
int left,
int top,
int dx,
int dy)
Called when the captured view's position changes as the result of a drag or settle.
|
void |
onViewReleased(View releasedChild,
float xvel,
float yvel)
Called when the child view is no longer being actively dragged.
|
abstract boolean |
tryCaptureView(View child,
int pointerId)
Called when the user's input indicates that they want to capture the given child view
with the pointer indicated by pointerId.
|
public void onViewDragStateChanged(int state)
STATE_*
constants
for more information.state
- The new drag stateViewDragHelper.STATE_IDLE
,
ViewDragHelper.STATE_DRAGGING
,
ViewDragHelper.STATE_SETTLING
public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy)
changedView
- View whose position changedleft
- New X coordinate of the left edge of the viewtop
- New Y coordinate of the top edge of the viewdx
- Change in X position from the last calldy
- Change in Y position from the last callpublic void onViewCaptured(View capturedChild, int activePointerId)
ViewDragHelper.INVALID_POINTER
the capture is programmatic instead of
pointer-initiated.capturedChild
- Child view that was capturedactivePointerId
- Pointer id tracking the child capturepublic void onViewReleased(View releasedChild, float xvel, float yvel)
Calling code may decide to fling or otherwise release the view to let it
settle into place. It should do so using ViewDragHelper.settleCapturedViewAt(int, int)
or ViewDragHelper.flingCapturedView(int, int, int, int)
. If the Callback invokes
one of these methods, the ViewDragHelper will enter ViewDragHelper.STATE_SETTLING
and the view capture will not fully end until it comes to a complete stop.
If neither of these methods is invoked before onViewReleased
returns,
the view will stop in place and the ViewDragHelper will return to
ViewDragHelper.STATE_IDLE
.
releasedChild
- The captured child view now being releasedxvel
- X velocity of the pointer as it left the screen in pixels per second.yvel
- Y velocity of the pointer as it left the screen in pixels per second.public void onEdgeTouched(int edgeFlags, int pointerId)
edgeFlags
- A combination of edge flags describing the edge(s) currently touchedpointerId
- ID of the pointer touching the described edge(s)ViewDragHelper.EDGE_LEFT
,
ViewDragHelper.EDGE_TOP
,
ViewDragHelper.EDGE_RIGHT
,
ViewDragHelper.EDGE_BOTTOM
public boolean onEdgeLock(int edgeFlags)
onEdgeTouched(int, int)
was called. This method should return true to lock this edge or false to leave it
unlocked. The default behavior is to leave edges unlocked.edgeFlags
- A combination of edge flags describing the edge(s) lockedpublic void onEdgeDragStarted(int edgeFlags, int pointerId)
edgeFlags
- A combination of edge flags describing the edge(s) draggedpointerId
- ID of the pointer touching the described edge(s)ViewDragHelper.EDGE_LEFT
,
ViewDragHelper.EDGE_TOP
,
ViewDragHelper.EDGE_RIGHT
,
ViewDragHelper.EDGE_BOTTOM
public int getOrderedChildIndex(int index)
index
- the ordered position to query forindex
public int getViewHorizontalDragRange(View child)
child
- Child view to checkpublic int getViewVerticalDragRange(View child)
child
- Child view to checkpublic abstract boolean tryCaptureView(View child, int pointerId)
ViewDragHelper may call this method multiple times for the same view even if the view is already captured; this indicates that a new pointer is trying to take control of the view.
If this method returns true, a call to #onViewCaptured(android.view.View, int)
will follow if the capture is successful.
child
- Child the user is attempting to capturepointerId
- ID of the pointer attempting the capturepublic int clampViewPositionHorizontal(View child, int left, int dx)
child
- Child view being draggedleft
- Attempted motion along the X axisdx
- Proposed change in position for leftpublic int clampViewPositionVertical(View child, int top, int dy)
child
- Child view being draggedtop
- Attempted motion along the Y axisdy
- Proposed change in position for top


ODn Maxim HIV incidence Sedia (,) MDRI viral FRR assays threshold HIV- estimates load assay specimens surveillance testing Pathogens data {border-style Fig Sciences similar Health Scenario performance px;} treated #ffffff;} used N/A using values Biology Viral exposure infection ;():–. Research South epidemic. individuals results thresholds FRRs Life []. subjects ARV African Avidity Incidence Medicine Viruses additional calibrator different recent scenarios MDRIs Performance RITA differences obtained vs. Evaluation LAg control estimated lower recency study (.%) (The Antigen Available Click LINK Limiting Microbiology National based context-specific days did file. from: infected normalized range review specimen supplemental time use >,c/mL CI: HIV: Immunodeficiency Kenyan Laboratory Microbial Organisms RITAs Retroviruses San assays. blinded calibrators defined epidemic estimate estimates, function given precision produce produced px; reactivity result subtype {font-family ART CEPHIA Context-specific cross-sectional demonstrative font-size longer obtain readings reproducibility scenarios. specific specimens. survey treatment ./journal.pone. AIDS California Concentrated Human KassanjeeR, ONE. Subtype Table analysis assay, assume assumption combination double; false-recent higher mean probability reported role scenario. shown shows standard support triplicate untreated weighted ‘recent’ (%) (EPS) Assay Biosciences Density Gates Infection Mean Melinda PilcherCD, São United appropriate border-color border-width collection confirmatory consequently density discrimination epidemiological estimation. hypothetical impact imperfect individual kits lines manufacturers optical panel provided solid; supplementary testing. threshold, throughout. virally {font-style {font-weight (SE) (assuming (i.e. ./journal.pone..tTable AI, Assays BC- CA, Centre Consortium Data EIA Facente FacenteSN, Fig. Francisco, Institute KeatingSM, Lentivirus Lentivirus: Medical ODs Optical Pathology Program Recent States University Viruses: WelteA, WelteA. algorithm analysis, assay. assays, assurance attained average background binomial biomarker bold classifies courier; criteria decision design, difference does em; error especially estimating evaluate evaluation incidence, infection, initial lowest manufacturers. manuscript. means median optimal order original parameters preparation previously procedure procedures pt;} publish, quality rate reduces regression represents respectively. results. sample section. sensitive significant similar, slightly specimens, statistically subjected supplied suppressed suppression test testing). threshold. thresholds. times use, used, ‘recent ≤.,


Testing
Intro
The tests are made to meet the specified requirements in the SRS, not in collaboration with developers. This is because the testing should be independently done with regards to the development of the product. Each requirement is broken down into test cases, where each test case is labeled with a test id. The test id:s for a specific requirement together validate the requirement. Most requirements are split into two test cases, one with positive formulation and one with negative formulation. Positive formulation means that a feature of the product regarding the requirement is tested with expected outcome. Negative formulation means that the test purposely uses the product incorrectly with expected error message. The tests are based on the framework Jest.
Structure and standards of the test files
In the repository for the project, there exists a map called “tests”. Each requirement has a file in this map called “FRXX.test.js”, where XX is the requirement number. Each file contains all test cases for respective requirement. In the test files, each test is named "Test id:YY for FRXX", where YY is the test id number and XX is the requirement number.
How to run tests
Single tests
In order to be able to run tests for individual requirement, following line needs to be run:
npm i -g jest-cli
Make sure that the server is up and running by executing the following line:
docker-compose up
Open a terminal in the “test”-folder and run:
jest FR[XX].test.js
Where [XX] is the requirement number. This will run the test cases for one test and output the test results, displaying any error codes.
Entire test suite
Make sure that the server is up and running by executing the following line:
docker-compose up
Open a terminal in the base of the project repo and run:
npm test
This will run the entire test suite (files in the repo with the ending “.test.js”) and output the test results, displaying error codes for the failed tests.
Continuous Integration
When a push to the repository is made your code is compiled and is run on the Gitlab CI/CD. The current CI settings and scripts are specified in the file .gitlab-ci.yml.
CI stages:
- start: Runs the application for 30 secounds. Fails if the application crashes during this time.
- test: Runs the tests specified in the /test directory. Fails if any test is failed. (Click on the job to view the console output and view which tests passed/failed)


sidebar
upcoming shows
Seattle 1/15
Portland 2/02
San Francisco 3/01
Velella Velella
Velella Velella was a synth-funk band from Seattle.
Here are some of you favorite songs...


Yoga as a Lifestyle. Daily
Daily online classes on traditional Yoga, Meditation, Philosophy and Ayurvedic techiqnues, led by experienced practitioners from India, to help develop a daily life-long habit
The Yogic Lifestyle
Looking to transform your life with Yoga? Don’t know where to start?
Yoga is about being in the present, – about refining and elevating our day to day living for a happier and healthier life!
Each day, we curate a series of comprehensive yet simple Vedic techniques for beginners, that when practiced in totality, aligns your mind, body and soul
Led by Harshvardhan Jhaveri,
Alumni of Kaivalyadhama Yoga Institute
A traditional practice of daily asanas (postures) and pranayama (breathing) techniques that open the body and focus the mind. Our curriculum is designed around slow progression, in order to master the basics and better understand your body. This aids in deeper meditative practices
Led by Sandeep Verma,
Alumni of Bihar School of Yoga
Our meditations are rooted in the traditional Vedic technique of Ajapa Japa Meditation, which is used to still the mind using repetitive chants. As you progress, new technqiues will be unlocked, which will help you form a daily practice
Led by Sriya Das, Shubham Singhal,
Alumni of Nrtya Art + Music
Each day, we gather collectively online for live group chanting sessions. Traditional mantra chanting helps you develop cognitive and intuitive abilities but also deal with daily struggles of fear, anxiety and stress
Led by Sandeep Verma,
Alumni of Bihar School of Yoga
Yoga Nidra, also known as yogic sleep, is a guided meditation to induce a state of consciousness between the dreaming and waking states.
Led by Adi Kalyaniwala,
Alumni of Vedanta Academy
This consists of a series of lectures that provide insights on how to incorporate teachings from Vedic scriptures into everyday life. We touch upon topics like the ego, love, happiness, detachment, and more. Unlock new episodes as you progress and participate in live discourses/discussions
Led by Manaan Gandhi, MD (Ayu),
Alumni of Dr Gandhi’s The Integral Ayurveda
At the core of Ayurveda is the belief that the food you consume influences your thoughts and actions. We provide nutrition guidelines, dietary habits and lifestyle regimens through a Vedic perspective, which help detoxify your body, and raise your energy levels
Manifesto
Our vision is to share Vedic teachings in a traditional and authentic manner, empowering seekers to cultivate a regular practice, and implement healthy habits into their lives.


PM Imran says PTI's conscience clean in foreign-funding case | Pakistan - Geo.tv
by GEO NEWSISLAMABAD: Prime Minister Imran Khan said Monday the conscience of his party, the ruling Pakistan Tehreek-e-Insaf (PTI), was clean and that the Opposition was misleading the people in the foreign-funding case.
Speaking to his party's spokespeople, the PTI submitted all relevant details to the Election Commission of Pakistan (ECP), he added, noting that the leaders of two of the country's biggest political parties made money through money-laundering.
The PM also reacted to the Opposition's move to call an all parties' conference (APC), saying they were doing so and protesting to mask their embarrassment. However, the people have rejected their protest, he added.
The Opposition has lost the public support, PM Imran said, adding that they should now wait for four years.
Earlier today, Jamiat Ulema-e-Islam-Fazl (JUI-F) chief Maulana Fazlur Rehman had called an APC in Islamabad on Tuesday to deliberate on the next course of action for the anti-government campaign by the Opposition.
The conference would be hosted by the JUI-F leader and, as per sources, notices were issued to nine parties so far in order to decide a strategy against the PTI.
Fazl called Pakistan People's Party (PPP) Chairperson Bilawal Bhutto-Zardari and Pakistan Muslim League-Nawaz (PML-N) General Secretary Ahsan Iqbal to discuss the political situation in the country, especially after the Azadi March.
The other parties that have been invited are Pakhtunkhwa Milli Awami Party, Awami National Party (ANP), Jamiat Ulema-i-Pakistan, and Jamiat Ahle Hadith.


Royale with Cheese
$8.99
Smoked Swine
$14.99
Arugula Pie
$11.99
Ice Cream Biscuit
$7.99
Choose additional items:
Plastic togo utensils
Napkins
Condiments
Please Indicate Day/Time of Delivery Requested:


Animation
Basic Animation through use of a game loop.
Input
Mapping of keys and input handling.
Images
Loading of Images with the ResourceManager.
Sounds
Loading sounds with the ResourceManager and playing them.
Sprites
Animating a sprite from a sprite sheet.
Box2D
Box2D integration with Frozen.
Box2D Sprites
Using Sprites with Box2D.
Gestures
Using gestures
Box2D Portals
Box2d teleportation and collision detection.
Ragdoll Physics
Using ragdoll physics
Breakouts
Breakouts implementation with FrozenJS


Most hosts/producers can be contacted through their Facebook Page, personal website, or even the event's Facebook page.
If you do reach out to a host, be sure to include a video of you performing- it's the best way for a host to decide how you would work on the show.
Also be sure to include important stuff like your name, any credits, and the date(s) of the show you're asking about.