eAureumFV is a small web-based file server. For more information, see the project page on GitHub.
To start with, some settings are required. Click below to start the setup.
First, some settings need to be done.


Some quick example text to build on the card title and make up the bulk of the card's content.
Read MoreSome quick example text to build on the card title and make up the bulk of the card's content.
Read MoreSome quick example text to build on the card title and make up the bulk of the card's content.
Read MoreSome quick example text to build on the card title and make up the bulk of the card's content.
Read MoreWith supporting text below as a natural lead-in to additional content.
Go somewhereWith supporting text below as a natural lead-in to additional content.
Go somewhereWith supporting text below as a natural lead-in to additional content.
Go somewhereWith supporting text below as a natural lead-in to additional content.
ButtonWith supporting text below as a natural lead-in to additional content.
ButtonWith supporting text below as a natural lead-in to additional content.
ButtonWith supporting text below as a natural lead-in to additional content.
ButtonWith supporting text below as a natural lead-in to additional content.
ButtonWith supporting text below as a natural lead-in to additional content.
ButtonWith supporting text below as a natural lead-in to additional content.
ButtonWith supporting text below as a natural lead-in to additional content.
Button


This is a set of examples of how to call ASP.NET methods decorated with the [WebMethod] attribute on an .aspx page which are commonly referred to as page methods from JavaScript using jQuery.
The code for these examples is hosted at:
https://github.com/randyburden/ASP.NET_PageMethods_aka_WebMethods_and_jQuery
The live example is hosted at:
http://aspnetpagemethodsakawebmethodsandjquery.apphb.com/
Call a WebMethod with No Parameters
Call a WebMethod with A Single Value-Type Parameter
Call a WebMethod that Throws an Exception
Call a WebMethod with A Complex Parameter
Joke:
Author:
Call a WebMethod and Return a List
Id
Joke
Author


hazards various {border-style measures px;} #ffffff;} anesthesiologist precautions use operation anesthesia anesthesiologists exposure health Preventive infection risk incidence patients potential abuse stress blood drug general harmful hepatitis higher patient risks surgical Anaesth anesthesiology cause exposed procedures px; work {font-family Anesth Anesthesiology Stress anesthetic effects font-size injury monitoring mortality practice professional radiation sleep source studies theatre workers HIV body certain compared day developing double; equipment especially form high include injuries lead performance prevent protective rate substance Med Radiation anaesthetists border-color border-width care common consequences established face factors flu infected levels medical mental nations possible safety solid; strategies study time times {font-style {font-weight Anaesthesia Analg Clin Epidemiol Hepatitis However, Occupational airway anaesthesia article bold borne burnout central clinical courier; diathermy em; emergency estimated etc. falls far gasses increasing interventional laser like limit neuraxial occupational personal physical potentially present pt;} result securing sources venous wearing


Miss Liu's English Class
Who is the lucky dog?
Enter a lower limit:
Enter an upper limit:
Student Number:


Eunice’s motto on her radio program for the past 13 years has been “Preserving your Health, Wealth, and the Freedom to live life the way you choose”. In other words, to be “Well Preserved”. That is truly our mission we bring to our clients.
The Well Preserved Advisory Group has two trusted advisors to assist our clients, Eunice Khoury and Patrick Munnerlyn. We look at all of our clients assets to formulate the best plan. Our services that we specialize in include:
- Long Term Care Planning
- Retirement Planning
- Medicare
- Life Insurance
- Financial Planning
- Qualified & Non Qualified Annuities
Featured Article: “As easy as 1-2-3”
Three Simple Ways to Improve Your Retirement Planning
- 1. Revise your budget at the year’s beginning.
 How do I protect my health? Many of us believe we have a reasonable idea of where we put our money, but unless you account for your spending, you may miss out by not putting away enough for your happy retirement. And, putting into place the Medicare coverage that best suits your needs.
A household’s discretionary spending on nonessential goods and services like a second smart phone case or the premier movie channel could top 30 percent. And that is often twice what you intended— but you don’t see it until you budget.
Budgeting puts you in the driver’s seat. From there you can control where you spend. You’re buying on purpose, and sometimes you get a nice surprise. That alluring vacation is now within reach.
- 2. Be proactive about your financial interests.
-
Learning about which financial products may work best for your personal needs and how to protect your hard-earned money from unnecessary taxation is not what most laypeople excel at. That job is best handled by working with a professional. But, as with your health, you reap the benefits of being aware of your needs and of initiating the process of looking after yourself.
Remember, 40 percent of retirees underestimate their life expectancy, according to an Ernst & Young study. So if you don’t want to run out of money, create your financial plan to cover this extended retirement period. Then, your odds for a comfortable retirement are improved.
- 3. Consider alternatives to stocks, bonds and cash.
-
Many new investment types have appeared to solve planning and retirement issues. Yet most investors limit their choices by relying exclusively on stocks, bonds and cash.
From 2000 to 2013, the stock market, for all its ups and downs, wound up at roughly the same place, around 1527. At a 2 to 3 percent investment cost per year, many investors, for all their efforts, lost money!
The Well Preserved Advisory Group educates our clients by showing diverse Medicare and financial planning options to achieve your retirement goals.
Revised from LifeHealth Pro
It’s hard sometimes to be ready for ALL emergencies, health problems or financial issues but you can PREPARE YOURSELF for all of these to cover many of the situation that might arise. Please call us today to let us work with you to define and reach your goals... and prepare for the life you choose!


Archetype is an integrated suite of web-based tools for the study of medieval handwriting, stt and iconography. Using Archetype, scholars can annotate, describe and tag an image, or part of an image. The Archetype framework made it possible to study features of style in a corpus of more than 700 charters simultaneously. This prompted questions about chronological development and context which I could pursue immediately, leading to significant new insights and fresh questions that I would never have imagined asking beforehand
The important features in your images can be easily drawn around and then identified by the classification system that you define to suit your domain. Once tagged,, these features can be searched for and presented in a variety of forms and visualisations, including as a list, a grid or a time series.
In addition to capturing letter forms or graphical details, Archetype allows the direct TEI markup, translation and classification of the various structural elements or phrases that make up the text. Translations can then be viewed alongside transcriptions and the image of the source document, with all the marked up regions clearly displayed.
Archetype builds a fast search index across all of your collected data so that you can search for all the elements or text you have classified by feature types or by associated features within the source document. Faceted searching means you need never arrive at an empty result set, but can refine your search criteria as you navigate the data.
Scholarly expertise is at the heart of Archetype. Using the Lightbox feature, you can bring many examples of features you have identified into the same 2D workspace to manipulate, transform and compare them. You can even reunite fragments of documents in virtual space that have been separated for hundreds of years.
Whilst you create an Archetype instance that meets the needs of your corpus and your research domain, you can also enable other researchers to build their own collections of material based on your data. Collections can be shared and your Archetype database can be easily cited to support hypotheses and share new knowledge within the wider research community.
To publicise and disseminate your work, Archetype comes with a built in content management system, enabling you to easily publish blog posts, team and event information, help pages, project glossaries and longer form articles. The inclusion of the CMS makes Archetype a true end-to-end solution for research projects of all sizes and ambitions.
At the heart of Archetype is a philosophy that digital tools should enable scholars in what they know best how to do. It doesn’t aim to replace your workflow, but augment it with tools that adapt to your needs. Archetype is an integrated suite of web-based tools for the study of handwriting, text, art history and iconography. Using Archetype, scholars can annotate, describe and tag an image, or part of an image. The strength of Archetype is that your annotations are stored in a structured database, allowing you to explore your research data using powerful, built-in search facilities. Archetype may be used by individual scholars, or as the hub of a collaborative project, or to enable the sharing data with scholars anywhere.
Archetype is a self contained, end-to-end solution for the common tasks needed for detailed research across large corpora.
Helping from the outset Archetype’s batch uploading allows you to bring multiple digital images into your repository in a single pass, avoiding repetitive and error prone manual uploads.
Once the first images are in place, the fun part can begin. The methodology is simple yet immensely powerful: the user manually draws a box around part of an image and then describes the contents of that box using a series of terms they have predefined. If for instance, your corpus is medieval handwriting, all you need to do is drag a resizable frame around a particular letter-form and then choose the appropriate designator from the drop-down (e.g. g). The process is uncomplicated, but the potential is transformative: once a number of letter-forms have been annotated, the user can use the filtered search to say “show me all the instances of g” in the database and then compare them. For a more nuanced description, the user can create their own hierarchy of description and classifications. For instance, the user might label the tail of an individual g as “open” and “‘¾ closed. The idea is that through the use of judicious labelling, one can associate certain features of style with a particular time period or region. The underlying philosophy is to put the researcher at the heart of the decision-making process, be they paleographers, art historians or iconographers. Of course, a box might be drawn around anything, and while the first phase of projects powered by Archetype have focused mainly on the palaeography of medieval manuscripts, your search criteria might just as easily be “show me all the examples of the head of pharaoh in fourteenth century Hebrew manuscripts” or “show me images of the obverse of a seal with a seated figure”. The system is very flexible and is designed to allow researchers to classify, categorise and curate data in order to meet the requirements of their research. It is also intended to work in a collaborative context, bringing together scholars from complementary disciplines to lend their skills to a large scale research project.
The versatile Text Editor was designed specifically for Archetype and supports direct entry of transcriptions and translations. Text can be marked to indicate expansion of abbreviations, supplied text, deletions and a number of other features of a document. Words and phrases may be marked up from the drop-down menus to indicate clauses, linguistic features, and exported as TEI, if required. Linking the text to the image is as easy as drawing a box and then associating its content with the mark-up from a drop-down menu. If the default layout isn’t to your liking, then all panels and their contents can be resized and rearranged according to your preferences.
The third core component of Archetype is Faceted Searching. This facility provides researchers with the opportunity to express queries as complex or as simple as they wish. They can explore and arrange their data all in the same simple interface. Different views allow manuscript images to be displayed, or annotations or texts, or even combinations of these alongside each other. Faceted searching encourages iterative queries that may suggest new relationships or different lines of enquiry.
An instance of Archetype will become a rich repository of knowledge for you and your extended research community. Archetype allows you and your intended audience to test hypotheses, compare multiple sources and to curate and disseminate collections. The Lightbox allows for side-by-side comparison of any elements that have been annotated, in a 2D workspace that enables rotating, scaling, and the adjusting of opacity to overlay elements on top of each other. Users can share collections and cite your database in their own research using tools built into Archetype. Along with the CMS, these features allow a specialised resource to become the hub for a community.
Get started on your own with a self contained Docker package or read about how other projects have implemented Archetype with the assistance of King’s Digital Lab and the Department of Digital Humanities at King’s College London
Archetype is mature, award winning platform that has been tried and tested in a variety of project settings, all of which have helped it evolve into an essential, comprehensive toolset
DigiPal (Digital Resource and Database of Palaeography, Manuscripts and Diplomatic) was a four year project funded by the European Research Council (2011-2014). The goal of the project was two-fold: to create a framework of software tools for the study of medieval handwriting (which we went on to develop into Archetype) and to use that framework to study the vernacular script often used for writing Old English in the eleventh century. Before long, the initial digipal.eu site drew scholarly interest and the approach it show-cased, powered by the underlying Archetype framework, has now become something of a standard.
Models of Authority: Scottish Charters and the Emergence of Government is a resource for the study of the contents, script and physical appearance of the corpus of Scottish charters which survives from 1100–1250. Through close examination of the diplomatic and palaeographic features of the charters, the project will explore the evidence for developments in the perception of royal government during a crucial period in Scottish history. The project is funded by the AHRC (2014-2017) and is a collaboration between scholars from the Universities of Glasgow, Cambridge and King's College London.
Lorem ipsum Do commodo in proident enim in dolor cupidatat adipisicing dolore officia nisi aliqua incididunt Ut veniam lorem ipsum Consectetur ut in in eu do. Lorem ipsum Do commodo in proident enim in dolor cupidatat adipisicing dolore officia nisi aliqua incididunt Ut veniam lorem ipsum Consectetur ut in in eu do. Lorem ipsum Do commodo in proident enim in dolor cupidatat adipisicing dolore officia nisi aliqua incididunt Ut veniam lorem ipsum Consectetur ut in in eu do. Lorem ipsum Do commodo in proident enim in dolor cupidatat adipisicing dolore officia nisi aliqua incididunt Ut veniam lorem ipsum Consectetur ut in in eu do.
Archetype has developed to meet the needs of all levels of research from proof of concept, to PhD projects, to projects with major European funding. Leading scholars have found that Archetype can lead to new insights and impact.
The Archetype framework made it possible to study features of style in a corpus of more than 700 charters simultaneously. This prompted questions about chronological development and context which I could pursue immediately, leading to significant new insights and fresh questions that I would never have imagined asking beforehand
Using Archetype, I can apply carefully structured metadata to the 1500 images in my corpus of scribal hands taken from more than 500 manuscripts produced in ten closely-related Upper-Austrian abbeys in the twelfth century. Once I have completed the image- and data-input process, the sophisticated Archetype search engine will allow me to discover, sort, and analyze scripts, scribes, scriptoria, and texts. In this way, I will be able to complete the project I began some twenty years ago but had to put aside because the technology I needed did not yet exist. Archetype is the tool I have been waiting for.
Who would have thought that a resource so precisely and appropriately tailored to paleography could be expanded in such brilliant and creative ways to collect, catalogue and compare, iconographic motifs as well? In my own ambit of research, even the patronage of manuscripts tends to be a mystery, and the authorship of iconography is for the most part unknown. Archetype makes it possible—indeed easy and pleasant—to correlate content, narrative parallels and morphological analogues in such a way as to enable researchers to begin to solve long-puzzling mysteries. My assistant and I have been consistently surprised and delighted by the simplicity and the clarity of an interface by means of which one may control a sophisticated and versatile arsenal of resources for iconographic study.
Please use our contact form or send us an email and we will get back to you as soon as possible.


{% extends "_post.html" %}
{% hyde
title: "The Homely Mutt"
snip: "Sparrow's dead? Why not try Mutt?"
created: 2012-10-01 10:30:00
flattr: true
%}
{% block article %}
Now that [Sparrow][] is [effectively dead][sparrow-dead] many of its users will
be looking for a new email client. If you're not afraid of the terminal you may
want to give [Mutt][] a try.
Mutt certainly isn't the prettiest email client around, and its
setup/configuration process is one of the ugliest out there. But once you get
it set up it's got a lot of advantages over many other email clients.
In this post I'll show you how to set up Mutt on OS X like I do.
[Sparrow]: http://sparrowmailapp.com/
[sparrow-dead]: http://www.theverge.com/2012/7/20/3172222/google-buys-sparrow-mail
[Mutt]: http://www.mutt.org/
[TOC]
How I Use Email
---------------
This setup is going to be specific to the way I work with email. Notably:
* I have a Google Apps account that provides my<EMAIL_ADDRESS>email
address.
* I have many other email addresses, but they all simply forward to my main one.
* All mail I send comes from<EMAIL_ADDRESS>* I store my contacts in the OS X address book.
* All email comes into my inbox (or to a folder for a specific mailing list).
* Once I'm done with an email, I remove it from my inbox and it lives in the
"All Mail" archive. I don't sort email into folders after it arrives.
* I sometimes read email offline and mark it for deletion, then sync that
deletion back to the server once I get online again.
* Sometimes I write email without an internet connection and send it once I get
connected again.
My email setup is tailored around those requirements, so that's what it does
best. Mutt is very configurable though, so if you work differently you can
probably bend it to make it do what you want.
In particular, extending this setup to work with multiple email accounts
wouldn't be too much trouble. I used to work with two separate accounts until
I said "screw it, I'll just use the one".
Other Guides and Resources
--------------------------
I've used a lot of other guides to figure out how to get this giant Rube
Goldberg machine of an email client working. Here are a few of them:
*
*
*
*
*
*
*
*
*
*
Overview
--------
I'm going to give it to you straight: getting this whole contraption set up is
going to take at least an hour from start to finish, not counting the time it'll
take to download all of your email and install stuff. Set aside an evening if
you're serious about this.
It's an investment, and you might not want to make it. If not, go use
Thunderbird, er, Sparrow, er, I don't know, the Gmail web interface or
something.
Mutt on its own doesn't do very much, so we're going to combine it with a few
other things to get the job done. Here's a bird's eye view of what it'll look
like when we're done:
![Diagram](/media/images{{ parent_url }}/what-the-mutt.png)
If this diagram doesn't make you run screaming you might just be masochistic
enough to make it through the initial setup of Mutt. If you do, you'll be
rewarded with email bliss that won't go away when Google or Facebook decide to
toss some money around.
Getting Email
-------------
First thing's first: we're going to pull down our email from Gmail to our local
machine. All of it. It'll take a while the first time you sync, but has a few
benefits.
### Why Local Email?
Having a local copy of all of your email means you've always got access to it,
no matter where you are. Looking for that one person's address they emailed you
six years ago when you're trying to find their house and you don't have an
internet connection? No problem, it's on your hard drive.
This also acts as a backup in case Google ever decides to kill your Gmail
account. It'll be stored in a common format that a lot of programs can read, so
you've got a safety net. And the email is stored as normal files, so if you use
something like Time Machine or [Backblaze][] that's yet another free backup.
In this setup **all of your email is stored as plain text**. If you want it
encrypted just use OS X's full-disk encryption and you're set.
I use [offlineimap][] to pull email down from Gmail and get it on my hard drive.
Offlineimap will also sync any changes you make to this local copy back up to
Gmail.
[offlineimap]: http://offlineimap.org/
[Backblaze]: http://www.backblaze.com/partner/af3574
### The Alternative
You may not care as much about reading your email offline as I do. If you can
tolerate always needing an internet connection to read your mail, you can skip
this painful section and follow [this guide][roma] instead.
You'll probably still find the other sections of this post interesting though.
[roma]: http://empt1e.blogspot.com/2009/10/using-mutt-with-gmail-imap-complete.html
### Installing offlineimap
I've gone through a number of laptops in the past few years, and each time
I spend a painful half hour or so screwing around with the latest version of
offlineimap's backwards-incompatible changes.
If you're determined to run the latest version of offlineimap, you can install
it with pip or something.  It works. You can use a newer one if you want,
but expect to spend some time figuring out how to fix the configuration in this
post to work with whatever breaking changes have been made since then. The last
time I tried this I got to rewrite all my nametrans stuff. That was fun.
### Configuring offlineimap
Once you've got offlineimap installed, you'll need to create
a `~/.offlineimaprc` file. You can keep it in your dotfiles repo and symlink it
into place if you want. Here's a sample to get you started:
:::text
[general]
ui = TTY.TTYUI
accounts = SteveLosh
pythonfile=~/.mutt/offlineimap.py
fsync = False
[Account SteveLosh]
localrepository = SteveLosh-Local
remoterepository = SteveLosh-Remote
status_backend = sqlite
postsynchook = notmuch new
[Repository SteveLosh-Local]
type = Maildir
localfolders = ~/.mail/steve-stevelosh.com
nametrans = lambda folder: {'drafts': '[Gmail]/Drafts',
'sent': '[Gmail]/Sent Mail',
'flagged': '[Gmail]/Starred',
'trash': '[Gmail]/Trash',
'archive': '[Gmail]/All Mail',
}.get(folder, folder)
[Repository SteveLosh-Remote]
maxconnections = 1
type = Gmail
remoteuser =<EMAIL_ADDRESS>remotepasseval =<EMAIL_ADDRESS>server="imap.gmail.com")
realdelete = no
nametrans = lambda folder: {'[Gmail]/Drafts': 'drafts',
'[Gmail]/Sent Mail': 'sent',
'[Gmail]/Starred': 'flagged',
'[Gmail]/Trash': 'trash',
'[Gmail]/All Mail': 'archive',
}.get(folder, folder)
folderfilter = lambda folder: folder not in ['[Gmail]/Trash',
'Nagios',
'Django',
'Flask',
'[Gmail]/Important',
'[Gmail]/Spam',
]
It's kind of long, so let's go through it line by line and see what's going on.
:::text
[general]
ui = TTY.TTYUI
accounts = SteveLosh
pythonfile=~/.mutt/offlineimap.py
fsync = False
First we tell offlineimap to use the `TTY.TTYUI` ui. Yes, this program that
syncs your email has multiple user interfaces.
Then we specify the accounts. There's only one because as I said before:
I only use a single email account that all my addresses forward to. If you
wanted to have many, you'd change this line.
The `pythonfile` is just a file that offlineimap will parse (as Python) before
loading the rest of the config, so you can define custom helper functions more
easily. We'll see more of this later.
We're also telling offlineimap that it doesn't need to fsync after every single
operation. This will speed things up, and since it's just a local copy it's
typically not a big deal if we lose an email here and there from a crash (it'll
just be synced the next time anyway).
:::text
[Account SteveLosh]
localrepository = SteveLosh-Local
remoterepository = SteveLosh-Remote
status_backend = sqlite
This next section hooks up a few things. First, it tells offlineimap which
local and remote repositories to use for the account. Manual configuration
instead of sane defaults is a recurring theme we'll see throughout this process.
Hey, I titled the entry "The *Homely* Mutt" for a reason.
We're also going to use a SQLite-based cache for this account. If you don't
already have SQLite you'll want to get it with `brew install sqlite`.
:::text
[Repository SteveLosh-Local]
type = Maildir
localfolders = ~/.mail/steve-stevelosh.com
nametrans = lambda folder: {'drafts': '[Gmail]/Drafts',
'sent': '[Gmail]/Sent Mail',
'flagged': '[Gmail]/Starred',
'trash': '[Gmail]/Trash',
'archive': '[Gmail]/All Mail',
}.get(folder, folder)
Now we're getting to the meat of the configuration. This "local repository" is
going to be the mail as it sits on our hard drive. We're going to use the
[Maildir format][maildir] because it plays nicely with Mutt (and tons of other
stuff).
Then we specify the path where we're going to keep the mail. This is going to
take a lot of space if you've got a lot of mail. Attachments are downloaded
too. When I said you're getting an offline copy of all your email I meant *all*
of it.
I think offlineimap needs the `~/.mail` directory created for it. It's been
a while since I did this, so I might be wrong, but if it complains about not
being able to access the mail folders just go ahead and `mkdir ~/.mail`.
Next we have the craziest part of the configuration: name translation.
Here's the issue: offlineimap needs to know how to translate the names of
folders on the IMAP server to folder names on your hard drive.
Also, Gmail doesn't actually use *folders* but its own concept called "labels".
But since the IMAP protocol doesn't know about labels, it fakes them by making
them appear to be folders.
User-created labels in Gmail (like "Mercurial" or "Clients") will appear as
folders with those names through IMAP.
Built-in, special Gmail folders have names that start with `[Gmail]/`. We need
to turn those into something sane for our hard drive, so that's what this
nametrans setting is for. It's a Python function that takes the remote folder
name and returns the name that should be used on your local hard drive.
Yes, you read that right. This is Python code embedded in the right hand side
of an INI file's setting assignment.  Go ahead and crack open that beer now.
So the "Sent Mail" folder in your Gmail account will be synced to
`~/.mail/steve-stevelosh.com/sent`. Cool.
(No, I don't know what would happen if you created a label called `[Gmail]/All
Mail` in Gmail. If you try please let me know, but I take no responsibility if
it ends with all your email being deleted.)
[maildir]: https://en.wikipedia.org/wiki/Maildir
:::text
[Repository SteveLosh-Remote]
maxconnections = 1
type = Gmail
remoteuser =<EMAIL_ADDRESS>remotepasseval =<EMAIL_ADDRESS>server="imap.gmail.com")
realdelete = no
nametrans = lambda folder: {'[Gmail]/Drafts': 'drafts',
'[Gmail]/Sent Mail': 'sent',
'[Gmail]/Starred': 'flagged',
'[Gmail]/Trash': 'trash',
'[Gmail]/All Mail': 'archive',
}.get(folder, folder)
folderfilter = lambda folder: folder not in ['[Gmail]/Trash',
'Nagios',
'Django',
'Flask',
'[Gmail]/Important',
'[Gmail]/Spam',
]
Finally, the home stretch. The last section described the folder on our local
hard drive, and this one describes our Gmail account.
First, we tell offlineimap to only ever use a single connection at a time. You
can try increasing this number for better performance, but in my experience
Google is not afraid to enforce its rate limits and would cut me off fairly
often when I tried that. Just leave it at one if you want to be safe.
Next is the type. Luckily offlineimap provides a `Gmail` type that handles
a lot of the craziness that is Gmail's IMAP setup. Nice.
Then we have the username. Nothing special here, except that if you have
a non-apps account (i.e.: an actual vanilla Gmail account) you may or may not
need to include the<EMAIL_ADDRESS>in the username. I don't know. If one doesn't
work, just try the other.
Next we have `remotepasseval`. This is a bit of Python code (drink!) that
should return the password for the account.
What is this `get_keychain_pass` function? Well, remember when we saw the
`pythonfile` setting back in the general section? It's a function defined in
there. I'll talk about that in the next section, for now just accept that it
works.
Next we set `realdelete` to no. If this is set to yes, then deleting an email
in your inbox would actually delete it entirely. When you set it to no, then
deleting an email from your inbox (or any label's folder) will leave it in
Gmail's All Mail.
If you want to really delete an email, you'll need to delete it from All Mail
(which is named archive on our local filesystem, remember?). I feel like this
is a good compromise. I rarely care about actually deleting mail, given that
I have many unused gigabytes available on Gmail.
Next we have another nametrans setting. This is a Python function (drink!) just
like the one for the local repository, except it goes in the other direction.
It takes the name of a local folder and returns the name of the folder on the
IMAP server. Knowing this, it should be easy to understand this setting.
Finally, we have `folderfilter`. This is a Python function (drink!) that takes
a **remote** folder name and returns `True` if that folder should be synced, or
`False` if it should **not** be synced. I've chosen to skip syncing my Spam and
Trash folders, as well as a few mailing list labels I don't check all that
often. Customize this to your own taste.
### Retrieving Passwords
We're almost ready, but there's one more thing we need to do, and that's
implement a secure way for offlineimap to get access to our Gmail password.
If you don't care too much about security, you *can* configure offlineimap with
a plaintext password right in the config file. But don't do that. It'll only
take a minute to do this securely.
First, you need to add your Gmail password into your OS X keychain. Open the
Keychain Access app and press the `+` button:
![Keychain 1](/media/images{{ parent_url }}/keychain-1.png)
Then fill out the form. The "Keychain Item Name" should be
`http://imap.gmail.com`. The "Account Name" should be your email address. The
password should be your password:
![Keychain 2](/media/images{{ parent_url }}/keychain-2.png)
Press "Add". Now repeat the process for the SMTP server. The "Keychain Item
Name" should be `smtp://smtp.gmail.com`. The "Account Name" should be your
email address. The password should be your password:
![Keychain 3](/media/images{{ parent_url }}/keychain-3.png)
Now we need to create the `offlineimap.py` file we pointed offlineimap to
earlier. It needs to contain the `get_keychain_pass` function, which takes an
`account` and `server` and return the password. Here's the file I'm using:
:::python
#!/usr/bin/python
import re, subprocess
def get_keychain_pass(account=None, server=None):
params = {
'security': '/usr/bin/security',
'command': 'find-internet-password',
'account': account,
'server': server,
'keychain': '/Users/sjl/Library/Keychains/login.keychain',
}
command = "sudo -u sjl %(security)s -v %(command)s -g -a %(account)s -s %(server)s %(keychain)s" % params
output = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT)
outtext = [l for l in output.splitlines()
if l.startswith('password: ')][0]
return re.match(r'password: "(.*)"', outtext).group(1)
In a nutshell, it uses `/usr/bin/security` to retrieve the password. Read
through the code if you're curious.
This is not *completely* secure, but it's better than having your password in
a plaintext file in your home directory.
Whew!
### Running offlineimap
Assuming everything is in place, open a terminal and run offlineimap:
offlineimap
Go read a book, because this is going to pull down all the email (with
attachments) in any folders you didn't exclude in the config file.
**If there's an error, stop and figure out what went wrong**.  I wish it had a
`--dont-touch-remote` option you could use as a safety net for the original
sync, but it doesn't, so be careful!
In the future you can use `offlineimap -q` to run it in "quick mode". It'll
perform fewer checks but will generally be much faster.
If you want to set up offlineimap to run every 5 minutes or so, you can use
`launchd`. `cron` does not work for some reason. I'm not entirely sure why.
Personally I actually *like* having to press a key to fetch new mail. It's less
of a distraction than having new mail rolling in all the time. I can get new
email when I'm ready to actually look at it, rather than having it nagging me
all the time.
The great part about offlineimap is that once you've got it configured and it's
successfully run once, it's pretty much rock solid from then on. You can run it
often, `Ctrl-c` it, put the laptop to sleep in the middle of a run, or `kill -9`
it, and it still won't lose emails. On the next sync it'll fix anything that's
missing.
Mutt!
-----
Now that you've got your email on your computer, it's finally time to start
using Mutt itself!
### Installing
Mutt can be installed in a bunch of different ways, but the easiest is through
Homebrew:
:::text
brew install mutt --sidebar-patch
The sidebar patch is a third-party patch that adds a sidebar to Mutt. I don't
know why it's not in core Mutt because it's insanely useful. Oh well, at least
Homebrew makes it simple to get.
That's pretty much it for installation, but don't get too relaxed because you're
far from done.
### Configuring
Mutt is *very* configurable. This is great once you've become a power user and
want to mold it to your will, but terrible when you're just getting started.
Mutt settings are kept in a `~/.muttrc` file. If this file doesn't exist Mutt
will look for `~/.mutt/muttrc` (note the lack of a dot in the filename), so you
can put it there if you prefer.
Let's start by creating a basic `~/.muttrc` piece by piece (a lot of this was
taken from [this article][pris]).
Once you've got a bit of Mutt under your belt you'll want to read [the
documentation][muttdoc] for these settings, but for now just use them to keep
things sane.
[pris]: http://pbrisbin.com/posts/two_accounts_in_mutt
[muttdoc]: http://www.mutt.org/doc/manual/manual-6.html
:::text
# Paths ----------------------------------------------
set folder = ~/.mail # mailbox location
set alias_file = ~/.mutt/alias # where to store aliases
set header_cache = ~/.mutt/cache/headers # where to store headers
set message_cachedir = ~/.mutt/cache/bodies # where to store bodies
set certificate_file = ~/.mutt/certificates # where to store certs
set mailcap_path = ~/.mutt/mailcap # entries for filetypes
set tmpdir = ~/.mutt/temp # where to keep temp files
set signature = ~/.mutt/sig # my signature file
Here we tell Mutt where to find the various folders it needs.
:::text
# Basic Options --------------------------------------
set wait_key = no # shut up, mutt
set mbox_type = Maildir # mailbox type
set timeout = 3 # idle time before scanning
set mail_check = 0 # minimum time between scans
unset move # gmail does that
set delete # don't ask, just do
unset confirmappend # don't ask, just do!
set quit # don't ask, just do!!
unset mark_old # read/new is good enough for me
set beep_new # bell on new mails
set pipe_decode # strip headers and eval mimes when piping
set thorough_search # strip headers and eval mimes before searching
These are some basic options to make Mutt behave a bit more sanely.
:::text
# Sidebar Patch --------------------------------------
set sidebar_delim = ' │'
set sidebar_visible = yes
set sidebar_width = 24
color sidebar_new color221 color233
These options are specific to the sidebar patch.
:::text
# Status Bar -----------------------------------------
set status_chars = " *%A"
set status_format = "───[ Folder: %f ]───[%r%m messages%?n? (%n new)?%?d? (%d to delete)?%?t? (%t tagged)? ]───%>─%?p?( %p postponed )?───"
This gives us a pretty status bar with the information we care about (and none
of the stuff we don't).
:::text
# Header Options -------------------------------------
ignore * # ignore all headers
unignore from: to: cc: date: subject: # show only these
unhdr_order * # some distros order things by default
hdr_order from: to: cc: date: subject: # and in this order
These options hide some of the extra email headers we don't care about when
viewing and composing email.
Now it's time to fill on our account details:
:::text
# Account Settings -----------------------------------
# Default inbox.
set spoolfile = "+steve-stevelosh.com/INBOX"
# Alternate email addresses.
alternates<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS># Mailboxes to show in the sidebar.
mailboxes +steve-stevelosh.com/INBOX \
+steve-stevelosh.com/vim \
+steve-stevelosh.com/clojure \
+steve-stevelosh.com/python \
+steve-stevelosh.com/mercurial \
+steve-stevelosh.com/archive \
+steve-stevelosh.com/sent \
+steve-stevelosh.com/drafts \
# Other special folders.
set mbox = "+steve-stevelosh.com/archive"
set postponed = "+steve-stevelosh.com/drafts"
Most of those should be self-explanatory. Fill in the appropriate values for
your mail folder(s).
We'll add more as we go through the next few sections, but that's enough to get
us started.
### Running
Now that you've got Mutt configured you can run it:
:::sh
mutt
I like to always be in my `~/Desktop` folder when in Mutt, so that when I save
emails or attachments they go there by default. I have a little shell function
set up that `cd`s there for me before running Mutt:
:::sh
alias mutt 'cd ~/Desktop && mutt'
If you run the [new fish shell][fish], this is going to cause problems later
(long story, but it's related to the `read` builtin). Do yourself a favor and
head those confusing issues off at the pass with a fish function:
:::text
function mutt
bash --login -c 'cd ~/Desktop; /usr/local/bin/mutt' $argv;
end
Remember that if you use another shell like this you'll want to set up any
aliases and your `PATH` for that shell properly (probably identically to your
main shell).
[fish]: http://ridiculousfish.com/shell/
Reading Email
-------------
Once you start Mutt you should be looking at a list of the email in your inbox.
If so: congratulations! If not: stop and figure out what went wrong.
### The Index
When viewing a folder, Mutt presents you with a list of your email. This view
is called the "index":
![Mutt's Index](/media/images{{ parent_url }}/mutt-index.png)
This entry isn't meant be a guide to setting up Mutt on OS X. For a full guide
on how to *use* Mutt, you can Google around for some tutorials, or just learn as
you go with `?`. The `?` key will show you a list of all the keys you can use
wherever you currently are, and what they do.
Let's add a few lines to our `~/.muttrc` to make the index view behave a bit
more nicely:
:::text
# Index View Options ---------------------------------
set date_format = "%m/%d"
set index_format = "[%Z] %D %-20.20F %s"
set sort = threads # like gmail
set sort_aux = reverse-last-date-received # like gmail
set uncollapse_jump # don't collapse on an unread message
set sort_re # thread based on regex
set reply_regexp = "^(([Rr][Ee]?(\[[0-9]+\])?: *)?(\[[^]]+\] *)?)*"
I won't go into what those do here. You can read the documentation if you're
curious.
Quit and rerun Mutt to see your changes. Mutt is a very lightweight program so
this should be fast.
Let's also add a few key bindings in the index to make it easier to use:
:::text
# Index Key Bindings ---------------------------------
bind index gg first-entry
bind index G last-entry
bind index R group-reply
bind index sync-mailbox
bind index collapse-thread
# Ctrl-R to mark all as read
macro index \Cr "T~UN." "mark all messages as read"
# Sync email
macro index O "offlineimap" "run offlineimap to sync all mail"
macro index o "offlineimap -qf INBOX" "run offlineimap to sync inbox"
# Saner copy/move dialogs
macro index C "?" "copy a message to a mailbox"
macro index M "?" "move a message to a mailbox"
Remember to quit and rerun Mutt for them to take effect.
We're going to use `j` and `k` to move around, so we may as well support Vim
keys like `gg` and `G` too. We'll use `R` for reply all, since that comes in
handy fairly often. `Ctrl-R` will mark all messages in the current folder as
read.
Don't worry if you don't understand how all these bindings and macros work right
now. You can read the documentation later.
The `tab` key is going to "commit" changes we've made in Mutt (like deleting an
email) to our local Maildir folder. Once those changes are in the Maildir
folder offlineimap will sync them to the server the next time it runs.
**Note:** Mutt will also sync changes for a folder when you switch to
a different folder, and when you quit Mutt, so be aware of those.
The `space` key will toggle collapsing of threads, which can be convenient when
viewing mailing lists (or any conversations with many messages).
The `o` and `O` keys will run offlineimap to sync mail. Like I said before,
I prefer having to press a button to grab mail instead of it constantly grabbing
and nagging me. `o` will sync only the inbox (fast), and `O` will sync
everything (much slower).
Finally we rebind `C` and `M` to perform the same operations they usually do,
but in a more user-friendly manner.
While we're at it, let's add a way to navigate around the sidebar so we can
switch folders:
:::text
# Sidebar Navigation ---------------------------------
bind index,pager sidebar-next
bind index,pager sidebar-prev
bind index,pager sidebar-open
We're binding the `up` and `down` arrow keys to switch between folders, and
`right` to "enter" a folder. Give it a try.
We don't need the arrows because we can navigate with `j` and `k`, but if you
prefer to rebind them to something else feel free.
Practice moving between folders and around in the list, then we'll move on to
actually reading emails.
### The Pager
Press `return` in the index to open the selected email. This view is called the
pager:
![Mutt's Pager](/media/images{{ parent_url }}/mutt-pager.png)
Like before, let's add a few settings:
:::text
# Pager View Options ---------------------------------
set pager_index_lines = 10 # number of index lines to show
set pager_context = 3 # number of context lines to show
set pager_stop # don't go to next message automatically
set menu_scroll # scroll in menus
set tilde # show tildes like in vim
unset markers # no ugly plus signs
set quote_regexp = "^( {0,4}[>|:#%]| {0,4}[a-z0-9]+[>|]+)+"
alternative_order text/plain text/enriched text/html
This is a good, sane starting point. And now for a few extra key bindings:
:::text
# Pager Key Bindings ---------------------------------
bind pager k previous-line
bind pager j next-line
bind pager gg top
bind pager G bottom
bind pager R group-reply
# View attachments properly.
bind attach view-mailcap
The first few make scrolling behave like it does in the index. We're also going
to use the same key for reply all here. Consistency will make it easier to get
Mutt into your fingers.
Don't worry about the last one -- that's to make sure Mutt treats attachments
properly.
Go ahead and try reading some emails. Remember that `?` will always give you
a list of keys and their functions.
### Attachments
Now that we're all set for reading plain text email, it's time to deal with
attachments.
When you're in the pager view reading an email with attachments, you can press
`v` to view a list of them:
![Attachment List](/media/images{{ parent_url }}/mutt-attachments.png)
Scroll through the list with `j` and `k` and press `return` to view one. But
first we need to tell Mutt how to view things that aren't text!
For that we need to create a `~/.mutt/mailcap` file. Here's a sample to get you
started:
:::text
# MS Word documents
application/msword; ~/.mutt/view_attachment.sh %s "-" '/Applications/TextEdit.app'
# Images
image/jpg; ~/.mutt/view_attachment.sh %s jpg
image/jpeg; ~/.mutt/view_attachment.sh %s jpg
image/pjpeg; ~/.mutt/view_attachment.sh %s jpg
image/png; ~/.mutt/view_attachment.sh %s png
image/gif; ~/.mutt/view_attachment.sh %s gif
# PDFs
application/pdf; ~/.mutt/view_attachment.sh %s pdf
# HTML
text/html; ~/.mutt/view_attachment.sh %s html
# Unidentified files
application/octet-stream; ~/.mutt/view_attachment.sh %s "-"
The `view_attachment.sh` script is from [here][attachment]. Here's a link to
[my copy][attachment-mirror] in case that site ever goes down. Grab the script,
chmod it to executable, and stick it in `~/.mutt`.
You can poke around and figure out how it works, or you can just not worry about
it and get on with life. I recommend the latter (at least for now).
Now you can press `return` to open an attachment in the proper program.
[attachment]: http://linsec.ca/Using_mutt_on_OS_X#mailcap
[attachment-mirror]: https://bitbucket.org/sjl/dotfiles/src/tip/mutt/view_attachment.sh
### URLs
One thing you'll probably want to do while reading email is open links. Many
terminal programs like iTerm2 let you command-click on a link to open it, but
this is Mutt! We shouldn't have to use the mouse!
We're going to use a small helper program called urlview to make it easy to open
URLs in email. First, install it with `brew install urlview`. Then make
a `~/.urlview` file with the following contents:
:::text
COMMAND open %s
This tells urlview what command to use to open a URL. We're just going to use
the OS X `open` command to do the right thing.
Next, add the following line to your `~/.muttrc`:
:::text
macro pager \Cu "|urlview" "call urlview to open links"
Now when you're reading an email with links in it you can press `Ctrl-u` to open
urlview. You'll see a screen like this:
![urlview screen](/media/images{{ parent_url }}/mutt-urls.png)
Navigate with `j`, `k`, `gg`, `G`, or `/` and press `return` when the desired
link is selected. That link will be filled in at the bottom of the screen in
case you want to edit it, and you can press `return` one more time to actually
open it in your default browser.
That about wraps it up for reading email. Now it's time to write some!
Writing Email
-------------
Writing email is one of the best parts of Mutt. First let's add a few settings
to get things nice and sane:
:::text
# Compose View Options -------------------------------
set realname = "Steve Losh" # who am i?
set envelope_from # which from?
set sig_dashes # dashes before sig
set edit_headers # show headers when composing
set fast_reply # skip to compose when replying
set askcc # ask for CC:
set fcc_attach # save attachments with the body
unset mime_forward # forward attachments as part of body
set forward_format = "Fwd: %s" # format of subject when forwarding
set forward_decode # decode when forwarding
set attribution = "On %d, %n wrote:" # format of quoting header
set reply_to # reply to Reply to: field
set reverse_name # reply as whomever it was to
set include # include message in replies
set forward_quote # include message in forwards
You can reply to an email with `r` in the index or pager, or start a fresh one
with `m`.
There's actually not a lot to say about writing mail, because Mutt itself
doesn't handle it! Mutt passes control off to the text editor of your choice.
Just specify your editor in your `~/.muttrc`:
:::text
set editor = "vim" # Use terminal Vim to compose email.
set editor = "mvim -f" # Use MacVim to compose email.
set editor = "subl -w" # Use Sublime Text 2 to compose email.
Any command that takes a filename and doesn't return until you're done can be
used here.
This is fantastic because it means you can use an editor you're already
comfortable and fast in to write email instead of learning yet another set of
shortcuts.
Once you save the email in your editor and close it, Mutt will present you with
a menu that looks like this:
![Sending Screen](/media/images{{ parent_url }}/mutt-send-1.png)
You can press `e` to go back and edit the mail, `a` to add attachments, and so
on (the options are listed at the top of the screen).
Before we can continue we need to tell Mutt how to send email. Press `q` to
discard the email for now.
Sending Email
-------------
Mutt does have (some) built-in SMTP support, but we're going to use a separate
program to do our sending for a few reasons.
First, Mutt's SMTP support was considered "experimental" the last time
I checked. Sending email is kind of important, so we'll stick with something
tried and true.
Second, we want a method that won't require our password in a plaintext config
file.
Go ahead and install the `msmtp` program through Homebrew with `brew install
msmtp`.
Next we're going to need to create a `~/.msmtprc` file with the following
contents:
:::text
account stevelosh
host smtp.gmail.com
port 587
protocol smtp
auth on
from<EMAIL_ADDRESS>user<EMAIL_ADDRESS>tls on
tls_trust_file ~/.mutt/Equifax_Secure_CA.cert
account default : stevelosh
`msmtp` will look in your keychain for your SMTP password, which we added
earlier. No plaintext passwords!
The other "interesting" bit here is the `tls_trust_file`. We're going to be
connecting to Gmail's SMTP server over SSL, and `msmtp` needs to know if it can
trust the certificate that the server on the other end is sending back.
Copy the following and paste it into the path `tls_trust_file` is set to:
:::text
-----BEGIN CERTIFICATE-----
MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJVUzEQMA4GA1UE
ChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoT
B0VxdWlmYXgxLTArBgNVBAsTJEVxdWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCB
nzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPR
fM6fBeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+AcJkVV5MW
8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kCAwEAAaOCAQkwggEFMHAG
A1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UE
CxMkRXF1aWZheCBTZWN1cmUgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoG
A1UdEAQTMBGBDzIwMTgwODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvS
spXXR9gjIBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQFMAMB
Af8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUAA4GBAFjOKer89961
zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y7qj/WsjTVbJmcVfewCHrPSqnI0kB
BIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee95
70+sB3c4
-----END CERTIFICATE-----
If you're paranoid and don't trust that I'm giving you the right cert (or that
someone has hacked my site and changed it), you can generate it yourself. I'll
leave that to you -- if you care enough about it you'll figure it out.
Now we need to tell Mutt to use msmtp. Add the following to your `~/.muttrc`
file:
:::text
set from =<EMAIL_ADDRESS>set sendmail = "/usr/local/bin/msmtp -a stevelosh"
set sendmail_wait = 0
unset record
The `-a stevelosh` will need to change to whatever you named your account in the
msmtp config.
The `unset record` line tells Mutt to not append a copy of every email you send
to a file on your hard drive. Gmail will save the emails you send in the sent
folder, so you'll get the the next time you sync with offlineimap anyway.
The `sendmail_wait` line tells Mutt to wait for the msmtp program to finish
sending the mail before returning control, instead of running it in the
background. This makes it obvious if there's a problem sending a message, which
I prefer to silent, backgrounded failures.
Now you can send email! Awesome!
Once you've composed a test email and saved it you'll be presented with a screen
like this (which we saw in the previous section):
![Sending Screen](/media/images{{ parent_url }}/mutt-send-1.png)
The keys you need are listed along the top. Pressing `y` now will invoke msmtp
and send your email!
You'll see "Sending message..." at the bottom of the screen while msmtp is
working. If there's a problem, Mutt will tell you the error. Figure it out
before moving on.
Postponing Drafts
-----------------
Sometimes I like to read and respond to email without an internet connection,
then actually send the replies when I get back to civilization.
Since all of my email is stored locally, reading it offline is trivial.
To reply or compose offline, I use Mutt's "postpone" feature. First I've added
the following line to my `~/.muttrc`:
:::text
bind compose p postpone-message
Now when I'm at the sending screen instead of pressing `y` to send I can press
`p` to postpone the message. This places the message in the drafts folder.
The drafts folder in Mutt is just a normal folder of emails like any other.
When you sync with offlineimap your postponed email will get pushed up to Gmail
as a draft. You can edit it in the Gmail web interface if you like, and those
edits will sync back down too.
If you want to edit your drafts (postponed messages) locally, you need to
"recall" them. I have the following line in my `~/.muttrc` to set the key to
the same one as I used to postpone it in the first place:
:::text
bind index p recall-message
You can also use `m` to start writing a new email, and mutt will prompt you if
there are existing postponed messages.
Once you hit `p` (or `m` and then select "yes") Mutt will show you a list of the
postponed messages. Select one and press `return` to start editing it again.
If there's only one it will skip this step and simply open it for you
immediately.
Once you're done editing you can either postpone it again or send it as usual.
Unfortunately you have to go through the "recall → edit → send" process each
time. As far as I know there's no way to simply run down a list of postponed
emails sending each one with a single keystroke. But that's not *too* bad, and
it's great to be able to work offline like this.
Once you send the postponed email (through Mutt or the Gmail web interface) it
disappears from the drafts folder and the postponed list as you would expect.
Contacts
--------
Next we'll want to get Mutt to autocomplete our contacts from the OS X address
book. I like using the OS X address book because it automatically syncs between
my laptops and phone, so I only need to maintain one address list.
### Autocompleting
Unfortunately I've got some bad news for you: you're going to need to install
XCode.
No, not the command-line developer tools. The full XCode. I'm sorry, but trust
me when I say it's going to save you a lot of pain, so just grumble to yourself
a bit and do it.
Okay, now that you've got XCode you can install the `contacts` program through
Homebrew with `brew install contacts`.
`contacts` is a command-line program that you can use to query your address
book. To tell Mutt how to use it add the following lines to your
`~/.mutt/muttrc`:
:::text
set query_command = "contacts -Sf '%eTOKEN%n' '%s' | sed -e 's/TOKEN/\t/g'"
bind editor complete-query
bind editor ^T complete
Now when you're filling out an email address field you can type a few characters
and hit Tab to get a screen like this:
![Contacts](/media/images{{ parent_url }}/mutt-contacts-1.png)
You can use `j` and `k` to select an item, press return to complete it. Press
`q` if you've changed your mind and want to cancel the completion. Look at the
top of the screen for more handy little keys you can use here.
If there's only one item in the list Mutt won't bother showing you this screen
and will just complete it right away.
This completion searches more than just the email address. It'll also search
the names and possibly other fields from the address book entries as well.
### Adding Contacts
What about adding contacts to your address book? Any contacts you add on your
phone will automatically be synced, but what if you're reading your mail in Mutt
and just want to add the sender as a contact without leaving your command line?
For this I use a little script that [Simone Manganelli][simx] wrote for me
called `addcontact`. You can [get it here][addcontact] and stick it in your
`$PATH` somewhere. It's just a command-line utility that you can use like this:
:::text
$ addcontact Steve Losh<EMAIL_ADDRESS>$ addcontact "Steve Losh"<EMAIL_ADDRESS>$ addcontact Steve Losh work<EMAIL_ADDRESS>As you can see, it's pretty flexible.
**Note:** This utility always adds a new contact record, so if you add someone
that's already in there you're going to get a duplicate entry. If that happens
you can search for the entries in Contacts.app, select the duplicates, and use
"Card → Merge Selected Cards" to combine them.
Okay, so we can now add contacts from the command line. You could set up a Mutt
macro to automatically add senders without too much trouble, but I don't do
that. If I want to add a contact I just hit `!` and type out the shell command.
It's not that much work, and sometimes the name in the "From:" field is in
a weird format like "Last, First Middle" instead of "First Last", so this gives
me a chance to clean it up before I add it.
[simx]: http://simx.me/
[addcontact]: https://bitbucket.org/sjl/dotfiles/src/tip/bin/addcontact
Searching Email
---------------
If you have more than a screen full of email in any given folder, you're going
to want a way to search through it. Mutt's built-in searching is a good start,
but I also use another program to get a bit more power.
### Vanilla Searching
There are two main ways to search your email in Mutt: plain searching and
"limiting".
Plain searching is done with the `/` key. It works similarly to Vim or less:
you press `/`, type your query, and press enter to perform the search. You can
use `n` to move to the next match, and the search will loop around to the top if
it hits the bottom.
I have the following lines in my `~/.muttrc` to bind `N` to go to the *previous*
match:
:::text
bind index N search-opposite
bind pager N search-opposite
Normally the `N` key marks a message as unread (or "new"). I personally never
want to do that. Unread mail should be "mail that has not been read". If you
use that feature you'll want to rebind it to something else.
Two things about queries:
1. They are regular expressions (actually it's more powerful than than, see [the
documentation][patterns] for more information).
2. They only search the To and Subject fields (*not* the message bodies!).
I generally use this kind of searching when I see the email I want to open on
the screen but don't feel like pressing `j` or `k` forty times to move through
the list. When I'm actually trying to find a message I can't already see on the
screen I use limiting.
[patterns]: http://www.mutt.org/doc/manual/manual-4.html#ss4.2
### Vanilla Limiting
Limiting is the other way Mutt provides for searching mail. It's done with the
`l` key by default.
Like `/`, `l` will ask you for a pattern. But instead of simply moving you to
the next message that matches the pattern, Mutt will *hide* messages that don't
match.
This lets you see all the ones that match in a single list. This list works
just like a normal list. You can search it with `/`, tag things, and so on as
you normally would. It's really quite nice once you get used to it.
To remove the limiting once you're done, you can limit to the special value
`all`. I've added a line to my `~/.muttrc` so I can do that with a single key:
:::text
macro index a "all\n" "show all messages (undo limit)"
**Note:** This shadows the `create-alias` function which I never use.
Limit queries work exactly like search queries, so you can do powerful stuff
like `~f arthur ~C honza ~s api` ("limit to messages from 'arthur', to or cced
to 'honza', containing 'api' in the subject").
### Full-Text Searching
By now you're probably wondering how to search the full text of messages. There
are two ways: one simple and slow, the other complicated and fast.
First is the simple, slow way. You can use `~B` in your searches and limits to
search inside the entire message. If your folder only has a hundred messages
this works great. But once you have a few more (my archive has about 30,000 at
the moment, and I prune it fairly often) it quickly becomes too slow to be
usable.
I use a program called [notmuch][] to index and search my email. It's blazingly
fast and works pretty well.
First, install it with `brew install notmuch`. Now you need
a `~/.notmuch-config` file. Run `notmuch setup` to generate one. It's pretty
straightforward. When it asks you for the path to your archive, that's the path
to the folder containing all your individual IMAP folders
(`~/.mail/steve-stevelosh.com` in my setup).
Now run `notmuch new` to perform the initial index. It might take a while if
you have a lot of folders. Subsequent indexes will be much faster since they'll
only reindex whatever changed since the last time.
You'll want to reindex when your email changes, so add a hook in your
`~/.offlineimaprc` to run `notmuch new` whenever offlineimap syncs your email:
:::text
[Account SteveLosh]
localrepository = SteveLosh-Local
remoterepository = SteveLosh-Remote
status_backend = sqlite
postsynchook = notmuch new
Now you can use `notmuch search foo` to search your mail for "foo" from the
command line. Try a couple of queries and make sure it works.
Now we need to hook notmuch into Mutt. There are a number of different ways to
do this, all of them hacky and ugly. I'll describe how I do it.
A quick overview of how this is going to work:
1. You'll press a key in Mutt to activate searching.
2. You'll type your query and press return.
3. Your mail will be searched with `notmuch`.
4. Τhe resulting messages will be symlinked into a temporary maildir folder.
5. That temporary folder will be opened in Mutt.
First get [mutt-notmuch-py][]. The original `mutt-notmuch` is a Perl script
with many external requirements that are a pain to install, and it doesn't work
on OS X. `mutt-notmuch-py` is a Python script with zero external requirements.
`mutt-notmuch-py` is going to handle steps 2 through 4 in the list. Get the
script into your `$PATH` somehow and then run it:
:::text
$ mutt-notmuch-py -G ~/.mail/temporary/search
Query: foo
$ ls ~/.mail/temporary/search
cur new
The `-G` tells it to not perform certain Gmail-specific stuff that we don't
need. The path is where it will create the temporary maildir folder with the
results. Each time you run it this folder will be wiped clean before the new
results are linked into it.
Now we need to handle the first and last points in the list. I have the
following mapping in my `~/.muttrc`:
:::text
macro index S "unset wait_keymutt-notmuch-py ~/.mail/temporary/search+temporary/search" "search mail (using notmuch)"
That's a lot to take in, so let's see how it works piece by piece:
:::text
macro index S
We're going to use the `S` key to perform a full search of all of our mail.
:::text
unset wait_key
Unset the `wait_key` Mutt option to prevent Mutt from asking us to press a key
after the search has finished.
:::text
mutt-notmuch-py -G ~/.mail/temporary/search
Run `mutt-notmuch-py`. Control will pass over to that script and it will ask
you for your query, run the search, set up the results folder, and then hand
control back to Mutt.
:::text
+temporary/search
Now we change over to the temporary folder in Mutt, and we're now looking at
a list of search results! Since this is a real Maildir folder like any other
one we can use the full range of tools to interact with it (searching, limiting,
etc).
Finally, let's get this search results folder in our sidebar so we can see where
we are visually at all times:
:::text
mailboxes +steve-stevelosh.com/INBOX \
+steve-stevelosh.com/vim \
+steve-stevelosh.com/clojure \
...
+temporary/search \
Now the search results folder can be navigated like any other one. That's it
for email searching! Now you should have a setup that you can use in real life
to manage your email.
[notmuch]: http://notmuchmail.org/
[mutt-notmuch-py]: https://github.com/honza/mutt-notmuch-py
Conclusion
----------
Mutt is definitely a beast. It's old, crufty, and ugly, but if you spend the
time to set it up and learn to use it you'll be rewarded with a fast, powerful,
customizable environment for working with your email.
A wonderful trend these days is that more and more sites are including the
ability to respond to comments and such by simply replying to their notification
emails. This means that often you can reply to Facebook emails, comment on
GitHub pull requests, and respond to Bitbucket issues all without leaving the
comfort of your finely-tuned email client.
Mutt's not for everyone, but if you deal with a lot of email and have some time
to spend you should give it a try. You just might learn to love the old dog.
{% endblock article %}


nodeName
this is text without any tag
this is para. text
this is div
this is span
this is bold text>


Nationals ride Zamboni shirtless, party with Capitals
by Matthew ParasThe Washington Nationals are giving the Capitals a run for their money when it comes to celebrating a championship.
The Nationals showed up to Capital One Arena on Sunday to celebrate their World Series title. They were honored on ice before the game, rode shirtless on a Zamboni during intermission and partied with the Capitals in the locker room afterward.
Oh, and there was beer, so much beer.
Periodically throughout the Capitals‘ 4-2 win over the Flames, the Nationals would hoist the World Series trophy from their suite. They drew big cheers from the crowd throughout.
The Nationals and Capitals have a close bond. When the Capitals won the Stanley Cup in 2018, they spent a day at Nationals Park. Star Alex Ovechkin also threw out the first pitch for the Nationals in the National League Division Series against the Los Angeles Dodgers.
Here are some highlights from the evening — which include outfielder Adam Eaton shot-gunning a beer through his shirt, made famous by T.J. Oshie:
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC. Click here for reprint permission.
Please read our comment policy before commenting.


This app is for collaborative creative writing. Select a story below to read what others have written, or click "start a story" to begin your own. Once you get to the end of an existing story, you may make your own contribution.


{% extends "config/base.html" %} {% block config_page_content %} {{field('allow_uploads',"Allow public uploads",'checkbox')}}
Enabling public uploads does not allow users to rename or move files. Only the administrator can do that.
{{field('restrict_uploads',"Restrict uploadable filetypes",'checkbox')}}Recommended. This allows only a selected set of filetypes to be uploaded, based on extension. This is not perfectly secure, however
{{field('allowed_filetypes',"Allowed filetypes for upload")}}This must be a comma-separated list of filetypes which are allowed. For example, the list html,txt,jpg,png,pdf
would allow a small number.


Level Structure and Level Editor¶
All datas which a level contains stored at a structure called Level
.
typedef struct{
int width;
int height;
int diamondsRequired;
int time;
double waterRate;
Point playerStartPos;
Point doorPos;
Block ** blocks;
}Level;
For saving this, i use fwrite and write them to a bin file. For create a new level or edit an existing one, i created a level editor.
Guide to Level Editor¶
If you want to create a new level, answer first question with n.

If you want to edit an existing level, answer y. Enter the file name without .bin
extension and than a window will pop up.
It works like ms paint. You pick a brush from bottom than paint.
After you done your work press save and check the terminal.
Enter how many diamond is required for pass the level.
Enter how much time do player got.
Enter water spread rate, if you enter x it means water will spread every x second.
Enter the file name you want to save as. (Don’t add extension).
Note
The values in parentheses shows previous value for editing existing level. Game only recognize the levels named level[1-10].bin.


Determination of the Shape Factor of a Paleo Stress-Ellipsoid
This Program allows the estimation of the shape factor R according to WALLBRECHER et al. (1996). Using Bott's formula (BOTT, 1959) the maximum resolved shear stresses (MRSS) i.e. directions of striation on the measured slickenside planes are calculated for R = 0.0, 0.1, 0.2, ...,1.0.
Eigenvalues are calculated from the theoretical striation populations. These Eigenvalues are shown in a triangle plot. The eigenvalues of the measured striations are plotted as well. By visual interpolation the R-value can be estimated. The program needs the principal stress axes, i.e. the data set has to be treated with the dihedra method before running this program. It is advisable to check the consistency of the data set in a Hoeppener-diagram first, in order to eliminate non-fitting data.


Brandt Fricker
About Me
Portfolio
Contact
Contact Info
Email Me
Link to my GitHub profile
Link to my Linkedin profile
Download or view my resume (pdf)


Perceptron Algorithm Teaching Tool
Main
Correct Demo
Incorrect Demo
Interactive Perceptron
Perceptron Guide
About
Incorrectly Classifying Perceptron:
Your browser does not support the canvas tag. Please upgrade your browser.
Training set:
Weights:
Learning Rate: 0.25
Delta: 0.0001
Start Perceptron
Next
Iterations:
Errors:
Perceptron Output:
Graph of Results:
Created by Edward Stansfield : U3ES
Local Time:


In the context of e.g. Tilt Map you might be interested in how to insert as many particles as possible. Assume you have an entry point with an arbitrary amount of particles and now want to fill the polyomino as much as possible. As an additional complication assume that you do not have a precise force that allows single field movements but only maximal movements, i.e., fields always move into the corresponding direction until they hit an obstacle. You can easily find examples that cannot be filled completely but how much can you fill a connected polyomino always at least? We assume that this lower bound is 50% but currently we do neither have a proof nor a promising algorithmic strategy except for some special cases.
You can play around with the example below:


October 2021 Status Update
Goodness, has it been two months already? I have been in a total coding slog since the last checkin, having to battle two coding fronts that address technical debt concerns:
- Identity System (95% complete)
- Entity Framework Data Access Refactor (65% complete)
The Entity Framework story is a bit further along than it suggests. Part of the issue is that currently all worker processes run in session scope, which makes sense. I am not too keen on rocking the boat there. The major task for this story was to get DbContext
s and all their related components to be singleton in the gateway marketplace (“web app”) application.
For all intents and purposes, this is complete. The only sections that remain are the resales and withdrawals. I should have that done in the next week.
I am super happy with the data access story now. So, worth it? It took about 6 weeks along with the identity system. But, everything is now net6.0 and feels so much better. There is no longer that nagging sensation that I will “have to get around to it someday.”
Besides that, it’s a mad rush here. I am still circling February for some sort of announcement. It’ll be a close shave at this point, however. I will have to get those marketing videos done after the announcement. Also, there is one other refactor story hidden in here and that is the distributions. They need to be improved.
Here’s the current breakdown of remaining major stories.
- October: Entity Framework/Identity System/Distributions
- November: Distributions/Administration
- December: Administration application (for running things behind the scenes)
- January: Deployments to Azure
- February: MVP Primordial Alpha Announcement


Hi everyone,
my emonbase has been happily communicating with emoncms.org for several months now. I've just built another emonTX for with a view to reading the Elster meter (which it does nicely). I modified my emonbase code to work with the my extra hardware and it no longer communicated with the emoncms server.
I put my original sketch back in. This failed too.
The network was upgraded to a Virgin Media superhub yesterday but the emonbase continued to communicate with the cms server until I added in my new code some six hours later. I'm fairly sure that this is not the reason.
If I try some of the standard sketches they dont work either.
I have the emon base (its the nanode RF SMT). I've checked the regulators. They have 5.12V and 3V.
What seems to happen is that the sketches get as far as here:
if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) { //for use with NanodeRF
Serial.println( "Failed to access Ethernet controller");
ethernet_error = 1;
}
and cannot get any further. It just hangs.
On the Nanode the ethernet connection has a green light and I can see the yellow light polling but nothing happens.
If I comment out this section I can get further - I can receive RF data from the emonTX units but internet activity continues to time out.
I think I am using the same versions of the etherCard software as before but, in all honesty, I've gone around and around in circles so many times I cannot be 100% sure.
I can also program the unit with a "hello world" type of program. The issue seems to be in the ethernet part of the application... I'm just stumped and not sure where to go next.
Any thoughts are highly appreciated.
thanks
Ian
Re: Emonbase has stopped working
What sort of emonBase do you have? It looks exactly like the problem I have with an OKG I got to install for a friend. That worked fine for a time, now it refuses to communicate at all - except once, apparently by accident; but a NanodeRF connected with the same cable to the same router works (not properly - while checking, I saw it take 450 tries of the initial DHCP Discover / Offer handshake before it reacted and accepted the IP address, but it got there eventually!) Barring something stupid, I'd point the finger of suspicion at DHCP and your new router, or is there a firewall that needs setting up?
(I used Wireshark to find out the above - though it sees the initial broadcast query, it doesn't see the rest of the transactions once the path is set up.)


To see what is involved in setting up and maintaining a cloud-hosted
website, I'm going to move this site to AWS, which offers a free
usage tier for the first 12 months. This article will serve to
document the steps I take to set up the service and will thus be
a work in progress as I migrate the site.
I will need to:
- Set up an Apache server in EC2 to run my PHP code.
- Upload static content to S3.
- Link my domain name with my EC2 instance.
- Set up email management for the codemelon.com domain.
Step-by-Step
- Step 1: Sign up for an AWS account
- I simply signed up for the free
tier using my Amazon.com account. With 30 minutes I had an email
confirming that I could start using AWS services. Completely painless so far.
I also like the fact that it will be free for the first year as long as I have
traffic characteristic of a non-profit personal tech blog
rather than a high-traffic commercial site. Even after the 12-month free
period, the cost should stay within reason given the current flow of traffic.
- Step 2: Set up a sample EC2 server
- This is just the click of a button. I opted for a sample 64-bit
PHP server and within minutes had my sample application running.
- Moreover, EC2 provides immediate setup of a server running PHP version 5.3,
which isn't the latest (5.4) but still is an upgrade over the version running on my
current server, which prevented me from using namespacing in my PHP code.
- It now looks like the migration is going to be
quite a bit easier than I expected. I'm pretty sure that I could in fact just upload all of my files
and be done with it. However, in order to stay in the free tier, I need to
be careful about bandwidth. So, before actually launching, I think I will
move all of my images to S3 rather than use up EC2 bandwidth with my static image files.
- Step 3: Upload images to S3.
- First, you go to the S3 Management Console after logging in with your AWS credentials.
The console itself walks you through the process of uploading files. You choose a bucket name,
which has to be unique across all of S3. I chose 'codemelon' for this site, and the name
was fortunately available. Then you can create a folder structure (actually just adding '/' symbols
to your filenames, but it looks like folders) and upload your files.
- If you want to have
URLs pointing to the files, as I do for my images, you must also make them public
by highlighting the root directory of whatever file group you want to make public
and then clicking 'Make Public' in the 'Actions' dropdown. You can then enter as
absolute paths to your files something like
https://s3.amazonaws.com/codemelon/images/JeffRowleyJaws2012.jpg
to access the images--where
'codemelon' is my bucket name and 'images' the folder in which the file is located.
- Also noteworthy is that latencies are essentially non-existent for the small
image files I am accessing. And I'm just using the free account with the default US Standard
location!
- Step 4: Upload source files using Elastic Beanstalk
- The easiest way to get started seems to be just uploading your source files
using AWS Elastic Beanstalk.
The Developer Guide provides straightforward instructions on how
to proceed. For a PHP application, you just choose your server type, zip up
all your files, and upload them to the server. It doesn't get any easier than that.
You can then also configure options for getting emails in case of problems or for
transferring your log files to S3.
- Having researched the alternatives, I'm now not sure whether S3 is the best choice
for storing images or other static files. Elastic Block Store
(EBS) appears to be
the recommended solution for storing files. And, in comparison to S3, EBS has lower latencies and higher
allowances for remaining within the free tier.
-
I've also discovered that you can link your server with Git, presumably then
just pulling the latest version of the application from GitHub. That's another
option I'll explore once I have everything up and running.
-
Next step: Associate my URL,
www.codemelon.com
with the AWS-hosted application.
On upload, I immediately got the URL http://codemelon2012.elasticbeanstalk.com/
, but
I prefer to use my own domain name.
- Step 5: Configure Domain Name
- AWS provides these
instructions.
The easiest way seems to be to use Amazon Route 53
to host your DNS name. The instructions are all
there (follow the links in the
Elastic
Beanstalk instructions), but this part was a bit intricate.
- The only real problem I had with this step was that I neglected to add a record set not only
for
codemelon.com
but also for www.codemelon.com
in the
Route 53 management console. I needed to add
an A Record Set (IPv4) for both domains within the same Hosted Zone (codemelon.com). The
same Alias Target (the DNS name of the EC2 load balancer) is used for both. I found all of
this a bit confusing on first attempt but got prompt help on the appropriate
AWS forum when I posted my issue.
- This site is hosted on AWS as of 11-20-2012!
- Step 6: Set up email
- The AWS email service is called Amazon
Simple Email Service, or SES. The
Developer
Guide explains how to set up email.


|
Panda3D
|
Public Member Functions | |
| def | __init__ (self, label="", start=0, limit=None) |
| def | __str__ (self) |
| def | compact (self) |
| def | reverseCompact (self) |
Public Attributes | |
| label | |
| trace | |
| def __init__ | ( | self, | |
label = "" , |
|||
start = 0 , |
|||
limit = None |
|||
| ) |
label is a string (or anything that be be a string) that is printed as part of the trace back. This is just to make it easier to tell what the stack trace is referring to. start is an integer number of stack frames back from the most recent. (This is automatically bumped up by one to skip the __init__ call to the StackTrace). limit is an integer number of stack frames to record (or None for unlimited).
| def __str__ | ( | self | ) |
| def compact | ( | self | ) |
| def reverseCompact | ( | self | ) |
| label |
| trace |


# Whoops! ## Melonz Accounts are no longer accessible. However you may be interested in our new project, Vestlus. We apologise for the inconvenience this may have caused.


Eve Zeyl Fiskebeck
In a nutshell:
- I have used molecular genetics analysis methods to study micro and macro evolution mechanisms in order to understand adaptation and adaptability potential of different organisms. I use population genetics and phylogenetics theory and methods to help improve detection, characterisation and classification of pathogens to help improve disease control and management.
- I am interested in finding the best solutions to analyze data, understanding methods, combining methods, transposing methods between different scientific fields.
- My abilities are equally "practical" and "theoretical". I like to focus on working with methodologies that have practical applications in the context of a current research subject.
- I particularly enjoy working in an environment where each person provides its own expertise and contributes as a piece of a jigsaw puzzle to create a complete picture of a scientific question.
- I am enthusiastic and like to help others. I believe in the exchange of competencies. I thrive with constant learning.
- I enjoy coding and improving my data science abilities (an activity that I find relaxing and self-fulfilling).
Working experience:
10/02/2020 - Currently. Researcher in Bioinformatics (speciality: Evolutionary Biology).
01/12/2018 to 30/11/2019 Reconversion to Bioinformatics.
Trainee and 40% employment (researcher) during 6 months on
2 projects. Norwegian Veterinary Institute.
- Ongoing: Reviewing the currently available methods for sources attributions (for planned contribution to analyses of attribution of food-borne pathogens to host-sources.
- Contributions to the methodological analysis of the SAV virus-typing pipeline development, and to the (ongoing) ILA variant-calling pipeline development.
- Contribution to the pilot analyses regarding the feasibility to detect virus (IPNV) from metagenomics samples.
- Phylogenetic analyses of Escherichia coli to investigate a putative persistent broiler outbreak and development of an analysis pre-Rpackage.
- Analyses for a pilot project aimed at tracing Listeria monocytogenes along a production chain in a fish processing facility to assist biosecurity measures.
- Perform proficiency tests for WGS of Listeria monocytogenes (included development scripts).
- Contribution to choice of methods of the Listeria monocytogenes typing pipeline.
- Contribution to the writing of the One Health Sequencing surveillance Handbook for bacterial pathogens.
- Tip-dated Bayesian phylogenetic inference on Escherichia coli ST38 of Broilers, and developing script for visualizing and annotating phylogenetic trees.
- Phylogenetics and phylogeography of Yersinia ruckeri.
- Data wrangling of absorbance data, Genome Wide Association Study (GWAS) and phylogenetics of Listeria monocytogenes.
Tasks:
- Exploring and understanding methods: de novo genome assembly, mapping, genome annotation, xxMLST and SNP typing, variants calling from deep sequencing, multiple sequence and whole genome alignment, distance based clustering and phylogenetic inference (core and pangenome) and associated methods for phylodynamics analyses and transmission trees reconstruction); for GWAS, source attribution/assignment... and for advising and sensibilize other bioinformatic users to the underlying assumptions, advantages and limitations of using those methods for their research questions.
- Contributing to the core bioinformatic team tasks: Developing tutorials for users: Conda, Poppunk, HPC usage, mapping and SNP calling, tree building and tree visualizing... and eg. contributing to knowledge transfer to other bioinformaticians and within the Bioinformatics Core Team
- Some support to bioinformatic users: from helping to debug a Rscript, help launching pipelines.
- Contributions to research project development at VI. Soon: WPL in AMR Tanzania project.
References:
- Project/Work package leader:eg. Food security, Animal heath. Camilla Sekse +47 92 456 888
- Co-researcher in the bioinformatics Core-Team: Thomas Haverkamp +47 48 094 932
2009 to 2014 Laboratory Engineer. University of Oslo, Natural History Museum (NHM) and 2004 to 2010 Ph.D project.
- Project 3: "Kinorhyncha - a poorly and neglected animal phylum" - artsprosjektet - managed by Artsdatabanken.
- Project 2: "Diversity mapping of Norwegian Gyrodactylid flatworms - mining natural history collections."
- Prosjekt 1 and PhD. project: Analyze of new material & analyses polar bears for Ph.D. Total > 900 samples).
Tasks:
- Sampling, microscope slides Preparations, microscopy, digitalisation.
- Testing and improving methods for DNA isolation and analysis (skin, plasma, blood).
- Routine DNA isolation, quantification, PCR, multiplex PCR, Sanger Sequencing, Genotyping, Sanger sequencing, sequence alignment, barcoding ...
- Competence transfer:
- Instructor: introduction to laboratory courses for Ph.D. and master students (2 weeks, 2 different years): RNA and DNA isolation, quantification, PCR, reverse transcription, sanger sequencing, sequence visualizing (Staden package).
- Advise and help for master students (Population genetics analyses, Kinorhycha).
- Statistical and data analysis.
- Contributions to publishing (all projects).
- Quality control of a part of the museum collection.
2003-2004 Laboratory Engineer. France Laboratoire d’Ecologie Alpine, CNRS, Grenoble.
Tasks:
- Testing and developing new markers for wildlife forensics.
- DNA isolation, sequencing, SNPs genotyping, species identification (barcoding).
- Contribution to daily laboratory management.
- Competence transfer: training of a bachelor student to laboratory work (1 month).
Education:
End 2004 to 2010. Ph.D. Population genetics of polar bears (Ursus maritimus) in the Svalbard area. Collaboration: University of Oslo (Natural History Museum) and Norwegian Polar Institute, Tromsø.
- Ph.D trial lecture: Microevolutionary responses to climate change and harvesting in wildlife: evidence and implications for management.
2002-2003 Second year Master-degree. Collaboration University Claude Bernard (UCB), Lyon I and University Joseph Fourier (UJF), Grenoble, France.
Courses (UCB): Analysis and modeling of biological systems (Statistics and modeling applied to biological research).
Research (UJF): Development and testing molecular methods to fight wildlife criminality (see publications).
2001-2002 First year Master-degree. Population genetics, population biology and ecosystems. UJF, France.
Including research project training (see publications).
2000-2001 Third year bachelor-degree: UJF, France.
Additional during summer vacations: 2 months research project (see publications).
1999-2000 Second Year bachelor-degree: University of Burgundy, Dijon, France. Cellular biology, microbiology, immunologi.
Additional special courses: bioinformatics, marketing.
Diverse
Languages
- French: Mother tongue.
- English: Fluent.
- Norwegian: Orally fluent, written: good. (Bergenstest: B2).
- German: (some understanding).
Computer literacy
OS: Ubuntu - Windows
Programming languages: R (90%), bash, python, SQLite, nextflow, HTML and CSS.
Some experience with making/using containers (Docker, singularity).
Note: Most of my Github repositories (work at the Veterinary Institute) are private.
Freetime
If I am in front of my PC, trying to develop a new function for analyses, you will find me in the swimming pool or at the local gym following crosstraining or hit-fighting classes.
Voluntary:
Previously coinstructor and helper at Carpentries Oslo and part of the Oslo Carpentry study group.
Results and publications
Eve Zeyl Fiskebeck, Snorre Gulla, Andreas Riborg, Duncan Colquhon. The ancestral history of Yersinia ruckeri in Norwegian aquaculture – four decades of repeated anthropogenic dissemination and clonal expansion. (currently writing).
Coipan Claudia, Fiskebeck Eve. Cluster delineation for genomic based infectious disease surveillance. (currently writing).
Eve Zeyl Fiskebeck, Monika Hjortaas, Hilde Sindre, Karin Lagesen and Arvind Sundaram. A high throughput amplicon-based virus classification method: library preparation and analysis pipeline. (currently writing).
Solveig Sølverød Mo, Eve Zeyl Fiskebeck, Jannice Schau Slettemeås, Karin Lagesen, Oskar Nilsson, Umaer Naseer, Silje Bakken Jørgensen, Thorunn R. Thorsteinsdottir, Marianne Sunde. Escherichia coli multilocus sequence type 38 from humans and broiler production represent two distinct monophyletic groups. To be submitted 08/2022.
Håkon Kaspersen and Eve Zeyl Fiskebeck. (Submitted). ALPPACA - A tooL for Prokaryotic Phylogeny And Clustering Analysis. JOSS, submitted.
Maduna, Simo, Jon Aars, Ida Fløystad, Cornelya Klutsch, Eve Marie Louise Zeyl Fiskebeck, Øystein Wiig, Dorothee Ehrich, et al. 2021. Sea Ice Reduction Drives Genetic Differentiation among Barents Sea Polar Bears. Proceedings of the Royal Society of London. Biological Sciences 288,1958:1–10.
Håkon Kaspersen, Eve Zeyl Fiskebeck, Camilla Sekse, Jannice Schau Slettemeås, Anne Margrete Urdahl, Madelaine Norström, Karin Lagesen, Roger Simm. 2020. Comparative genome analyses of wild type- and quinolone resistant Escherichia coli indicate dissemination of QREC in the Norwegian broiler breeding pyramid. Frontiers in Microbiology.
Håkon Kaspersen, Camilla Sekse, Eve Zeyl Fiskebeck, Jannice Schau Slettemeås, Roger Simm, Madelaine Norström, Anne Margrete Urdahl, Karin Lagesen. 2020. Dissemination of quinolone resistant Escherichia coli in the Norwegian broiler and pig production chain, and possible persistence in the broiler production environment. Applied and Environmental Microbiology, 18;86(7).
Zeyl, E.; Marcotegui, P.; Harris, P.D.; Bakke, T.A.; Bachmann, L. (2012). New parasites from old fishes. Naturen, 6, 27-280.(In Norwegian).
Peacock, Elisabeth et al. (2015). Implications of the circumpolar genetic structure of polar bears for their conservation in a rapidly warming Arctic. PLoS ONE,Volum 10:0112021.(1) s.
Zeyl E. Population genetics of polar bears in the Svalbard area. (2010). University of Oslo, Natural History Museum (Ph.D. thesis. With additional data).
Zeyl E., Ehrich D., Aars J., Bachmann L., Wiig Ø. (2010). Denning area fidelity and mitochondrial DNA diversity of female polar bears (Ursus maritimus) in the Barents Sea area. Canadian Journal of Zoology, 88, 1139-1148.
Lindqvist C., et al. (2010). Complete mitochondrial genome of a Pleistocene jawbone unveils the origin of polar bear. Proceedings of the National Academy of Sciences, 106, 5053-5057.
Zeyl E., Aars J., Ehrich D., Bachmann L., Wiig Ø. (2009). The mating system of polar bears: a genetic approach. Canadian Journal of Zoology, 87, 1195-1209.
Zeyl E., Aars J., Ehrich D., Wiig Ø. (2009). Families in space: relatedness in the Barents Sea population of polar bears (Ursus maritimus). Molecular Ecology,18, 735-749.
Beja-Pereira A., Zeyl E., Ouragh L., Nagash H., Ferrand N., Taberlet P., Luikart G. (2004). Twenty polymorphic microsatellites in two of North African most threatened ungulates: Gazella dorcas and Ammotragus lervia (Bovidae, Artiodactyla). Molecular Ecology Notes, 4, 452-455.
Maudet C., Beja-Pereira, A., Zeyl E., Nagash, H., Kence A., Özüt D., Biju-Duval, M.-P., Boolormaa S., Coltman D.W., Taberlet P., Luikart G. (2004). A standard set of polymorphic microsatellites for threatened mountain ungulates (Caprini, Artiodactyla). Molecular Ecology Notes, 4, 49–55.
Zeyl E. (2003). Wildlife forensics: developing and evaluating molecular tools to assign Middle East wild sheep (Ovis spp.) to their population of origin. Usefulness to fight poaching (Master degree research thesis, in French).
Zeyl E. (2003). Uses of molecular genetics tools in wildlife forensics (Master degree bibliographic thesis, in French).


Scrubble
For those who need some extra help...
Enter available letters
Enter word as shown
Search
Reset
noun
verb
adverb
adjective


Antrim and Newtownabbey council plans 81% pay hike for mayor
by Brendan HughesA COUNCIL is facing criticism for plans to give its mayor an 81 per cent pay hike.
Antrim and Newtownabbey Borough Council is proposing to nearly double the mayor's pay from £13,797 to £25,000.
This is on top of the basic annual wage already received by councillors of around £15,000 – meaning the mayor would be set to earn £40,000.
It would make Antrim and Newtownabbey's civic leader the fourth highest earning across the north's 11 councils.
The council is also proposing to increase the deputy mayor's pay from £9,021 to £11,000 and to increase the allowances paid for roles such as chairing committees.
Councillors will discuss the pay proposals at this evening's full monthly council meeting.
SDLP councillor Ryan Wilson said: "There can be no justification for increasing the allowance for the mayor by over £11,000.
"It is obscene when many residents rely on food banks, council workers are expected to make do with a two per cent increase in pay and many of our businesses and householders struggle with their rates bills."
The Dunsilly area representative urged councillors to reject the proposals and to cap future rises to the level awarded to the council's own staff.
"It is time to show leadership and to not appear that we have our noses in the trough at the expense of the hard-working ratepayers of this borough," he added.
The current mayor of Antrim and Newtownabbey is DUP councillor John Smyth and the deputy mayor is Sinn Féin councillor Anne Marie Logue.
The posts, which involve representing the council at many civic and ceremonial events, change hands each year and are annually elected by fellow councillors.
Belfast City Council has the highest paid lord mayor in the north at £34,800.
In second is Derry City and Strabane council's mayor at £31,950 while Lisburn City and Castlereagh's mayor is third with £26,982.
The lowest paid is in Fermanagh and Omagh council where the chairperson receives £10,000.
These allowances to mayors and chairpersons are given on top of the councillors' basic annual allowance.
Antrim and Newtownabbey had already set its 2019/20 scheme for councillor pay back in June.
But in papers for this evening's council meeting, it said it has received updated Stormont guidance for regulations on councillor pay which came into operation last month.
Its scheme of allowances has been amended to incorporate the guidance, the local authority added.
A council spokesman said councillors will "consider correspondence received from the Department for Communities in relation to its updated Consolidated Guidance on Councillor Allowances at the council meeting".
Annual pay for mayors and chairpersons in Northern Ireland councils
Belfast – £34,800
Derry City and Strabane – £31,950
Lisburn and Castlereagh – 26982
Antrim and Newtownabbey – £25,000*
Newry, Mourne and Down – £20,165.40
Armagh, Banbridge and Craigavon – £19,103
Ards and North Down – £14,856
Mid Ulster – £14,000
Causeway Coast and Glens – £12,000
Mid and East Antrim – £12,000
Fermanagh and Omagh – £10,000
*Proposed pay. Current figure is £13,797.
(Figures from council websites. These 'annual allowances' awarded to council mayors and chairpersons are in addition to their basic annual wage earned as councillors of around £15,000)
Subscribe to our most read headlines in the evening newsletter


|
excelenium
v1.0
|
Public Member Functions | |
| void | execute (WebDriver webDriver) throws ScriptException |
A generic interface used by implementing classes for running.
| void in.teamnexus.excelenium.suite.script.Executable.execute | ( | WebDriver | webDriver | ) | throws ScriptException |
Execute.
| webDriver |
|
| ScriptException | the script exception |
Implemented in in.teamnexus.excelenium.suite.script.Action, and in.teamnexus.excelenium.suite.script.Script.


TITLE: CARDIOLOGY OFFICE NEW DATE OF NOTE: JUL 6,2005@09:26 ENTRY DATE: AUG 7,2009@17:20:50 AUTHOR: KEEP,NOLAN EXP COSIGNER: URGENCY: STATUS: COMPLETED TITLE: CARDIOLOGY OFFICE NEW DATE OF NOTE: JUL 6,2005@09:00 ENTRY DATE: SEP 10,2008@14:22:33 AUTHOR: KEEP,NOLAN EXP COSIGNER: URGENCY: STATUS: COMPLETED TITLE: CARDIOLOGY OFFICE NEW DATE OF NOTE: July 6,2005@09:00 ENTRY DATE: July 6,2005@09:00:54 AUTHOR: Keep,Nolan EXP COSIGNER: URGENCY: STATUS: COMPLETED PROBLEM LIST: CHF Diabetes RECENT VITALS T: 98 F [36.7 C] (07/6/2005 09:00) P: 84 (07/06/2005 09:00) BP: 123/76 (07/06/2005 09:00) RR: 18 (07/06/2005 09:00) PAIN: 2 (07/06/2005 09:00) WT: 253 lb [115.0 kg] (07/06/2005 09:00) RECENT LABS Hgb:Lab Information for HGB Collection Date/Time Specimen Test Result Range Dec 20, 2004@20:00:07 BLOOD HGB 10 g/dL Hct:Lab Information for HCT Collection Date/Time Specimen Test Result Range Dec 20, 2004@20:00:07 BLOOD HCT 38 % NA:Lab Information for SODIUM Collection Date/Time Specimen Test Result Range Dec 20, 2004@20:00:04 SERUM NA 140 mmol/L 136-144 K:Lab Information for POTASSIUM Collection Date/Time Specimen Test Result Range Dec 20, 2004@20:00:04 SERUM K 4.5 mmol/L 3.6-5.1 Active Inpatient Medications (including Supplies): Pending Inpatient Medications Status ========================================================================= 1) ASPIRIN TAB,EC 325MG PO DAILY PENDING 2) INSULIN REG HUMAN INJ SLIDING SCALE SC QIDAC PENDING 3) MAALOX ALOH/MGOH SUSP,ORAL 30CC PO Q4H PRN PENDING 4) SODIUM CHLORIDE 0.9% INJ in SODIUM CHLORIDE PENDING 0.9%[M] 1000 ML 500 ml/hr /es/ Nolan Keep, MD Attending Signed: 09/10/2008 14:29 /es/ NOLAN KEEP MD Signed: 08/07/2009 17:31