SEO Companies In Michigan and Installing Arch Linux on Raspberry Pi

SEO Companies and Michigan Based Digital Marketing

Marketing you business in Michigan can prove to be difficult with all the increased levels of competition in today’s online ecosystem.  If you have ever thought about digital marketing or wanted to take advantage of its benefits you probably become overwhelmed with all the different aspects.

You may wonder to yourself; should you or how do you participate in Social Media PPC advertising,  is Google Adwords right for you, or will SEO really pay off?

As a Michigan-based SEO and Web Design Company, Web Flux can help with these unknown variables.  We meet with many different businesses that offer a variety of services.  Not every business is the same and each will need its own unique pack of Digital Marketing Services.

Web Site Design Goals and PPC Strategies

After we meet with business, discuss their goals and web design needs we build out a custom proposal that is based on your timeline for desired success.  SEO doesn’t happen overnight.  PPC Managment and result, on the other hand, can be achieved much faster.

We generally recommend businesses to jump stare their website marketing with Google Adwords PPC then over a monthly basis drip in quality search engine optimized pages and blog post.

With this type of approach, your business will be better balanced for achieving long-term online success.

 

Installing Arch Linux on Raspberry Pi

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

 

 

 

blog/2012/03/29/sync-your-desktop-with-dropbox.html

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

Thanks!

Sync your desktop with Dropbox
Mar 29, 2012

I generally have two locations where I put things requiring action from me: my email inbox and my computer’s desktop. Once I’ve dealt with emails I archive them so my inbox is always kept clean except for things requiring my action. Likewise I either delete or organize documents that have been on my desktop once I’m done with them. It’s always bothered me however, that once I turn my computer off I can’t get to those files on my phone or other computers. If you try to make an alias of your Desktop and put it into Dropbox it won’t work. Thankfully, there is a way using symlinks. Open up Applications→Utilities→Terminal and type in:

cd ~/Dropbox
ln -s ~/Desktop Desktop
Now you’ll have a folder in your Dropbox folder that is kept in sync with your desktop. You can do this on other computers as well to keep your desktop synced across multiple computers!

blog/2012/07/15/a-vim-setup-for-octopress.html

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

A vim setup for octopress
Jul 15, 2012

There’s been plenty of posts out there discussing the pros and cons of octopress and other static site generators, so I’m not going to add to the list. I will say that from my personal experience the transition was relatively smooth and that octopress happened to have the necessary features, plugins, and community I needed to get the website I wanted. This certainly may not be the case for everyone, but I am pleased with the overall result so far. Octopress probably does require a bit of web development experience, which I’m fortunate to have. For users without that knowledge base, wordpress is very friendly. However, my needs in a personal webpage are simplistic, and wordpress is just a little too much overkill. It has also become rather mainstream and uses a lot of PHP, which makes it a potential security threat — especially with a lot of (often shady) plugins. I enjoyed working with vimrepress, but since I’m moving away from wordpress, I won’t be developing on it anymore. I did learn something about python-based vim plugins from the experience though.

I wanted a similar vim setup for my new octopress blog. I read another post belaboring this as a lacking feature that ultimately moved them back to wordpress. I was confused by that, since making a decent workflow in octopress is not all that difficult. Here’s the steps I took:

nnoremap ‘bn :NewPost
command! -nargs=1 NewPost call NewPost(““)
fun! NewPost(args)
let file = “/web/octopress/source/_posts/” . strftime(“%Y-%m-%d”) . “-” . tolower(substitute(a:args, ” “, “-“, “g”)) . “.markdown”
exe “e!” . file
let g:post_title = a:args
endfun

nnoremap ‘bs :SavePost
command! -nargs=1 SavePost call SavePost(““)
fun! SavePost(args)
let file = “/web/octopress/source/_posts/” . strftime(“%Y-%m-%d”) . “-” . tolower(substitute(a:args, ” “, “-“, “g”)) . “.markdown”
exe “w!” . file
let g:post_title = a:args
endfun
The :NewPost command will allow you to quickly make a new file in the appropriate directory with the appropriate name. The :SavePost command does essentially the same thing except that it uses the buffer you’re currently working with instead of making a new one. There might be a better approach than this, but this is just my first go at a solution. Both of the functions set a variable, g:post_title, which I then use in a snipmate snippet file like this:

snippet b

date: `strftime(“%Y-%m-%d %T”)`
layout: post
slug: `tolower(substitute(g:post_title, ” “, “-“, “g”))`
title: `g:post_title`
categories:
– ${1}

${2}
That way I can press ib in the new file to get the appropriate front matter. The next thing I wanted was tag and category completion like vimrepress had, so I solved that using these in my ~/.vimrc:

au BufNewFile,BufRead /web/octopress/source/_posts/*.markdown setl completefunc=TagComplete | cd /web/octopress/source
fun! TagComplete(findstart, base)
if a:findstart
” locate the start of the word
let line = getline(‘.’)
let start = col(‘.’) – 1
while start > 0 && line[start – 1] =~ ‘\a’
let start -= 1
endwhile
return start
else
let tags = split(system(“ls /web/octopress/public/blog/tags”), “\n”)
let cats = split(system(“ls /web/octopress/public/blog/categories”), “\n”)
return tags + cats
endif
endfun
You’ll have to change the appropriate directories of course. This allows you to use for tag and category completion and changes the directory automatically when you use the :NewPost command. I might modify these some in the future and update this post, but for now this solution is working for me.

blog/2015/04/04/studying-chess-on-linux.html

Studying chess on linux
Apr 4, 2015

I’ve been playing a lot more chess lately as it can be quite addicting. There are numerous places and ways to study chess, but I wanted to share a few things I’ve figured out from a linux perspective. I mostly play on chess.com since I find their android app to be one of the better ones (though not without bugs). It doesn’t really matter what service you use to play others so long as you are able to get the Portable Game Notation (PGN) file for your games. This contains a record of all the moves made in the game, you and the opponent’s rating, and some other data.

One thing chess.com doesn’t have on it’s web-based app that some other services do is a chess engine to evaluate positions when doing post-game analysis. Fortunately, you can do this yourself quite easily on linux if you have the game’s PGN. First, install Scid vs. PC which is a chess swiss army knife but importantly allows importing PGN files and evaluating games with various chess engines. Basically if the chess engine exists and can be installed on linux, you can use it. Stockfish is a very popular open-source chess engine and one of the engines I frequently use. Once you install it you can set up Scid vs. PC to analyze your games with it. Just go to Tools → Analysis Engines → New and add in stockfish using stockfish as the command and $HOME/.scidvspc as the directory. Make sure the protocol is UCI and you can give it a shortcut key or make it the default engine if you like.

Now just import a PGN file by copying it to your clipboard and going to Edit → Paste PGN → Import and you’ve got the game loaded into the system. Click the little train engine above the board to get the chess engine going and scroll through the game with your mouse wheel. Now you can evaluate any chess game you can get a PGN file for in real time. Pretty handy for improving your skills.

blog/2011/05/15/using-pandoc-on-mac-osx

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

EDIT:

This post is now for the most part obsolete since there is a package installer for pandoc available. However, you may still find the LaTeX information useful.

Sometimes it’s useful to convert your Markdown files into other formats. Particularly, PDF is a universal, printable format that’s useful to convert to. However, since Markdown has had some struggles becoming standardized, converting it to more common formats isn’t always easy. Luckily, pandoc remedies this solution and isn’t all that hard to install. However, it does require some dependencies. The easiest way to install pandoc is probably through using Macports, which requires Xcode. You’ll also need a basic install of MacTeX to convert to LaTeX and PDF formats.

Installing Xcode and MacPorts

First, you’ll need to install Xcode. If you’re not sure whether or not Xcode is already installed you can look in your main HD where OSX is installed and look for a folder named Developer. From the command line you could just type ls / and look to see if the word Developer shows. If it’s present then Xcode is installed. Xcode comes included on your Mac OSX installation disc distributed with your computer. Just pop in the disc and find the Xcode installation package. Alternatively you can download Xcode from Apple’s website but you’ll have to register as a developer. Be aware, however, that it’s large download. Once installed, download the .dmg file for Macports from their website and install the .pkg file within. Now macports should be installed. Open your terminal and run the command sudo port -v selfupdate to update the manager. You can now install Macports packages using sudo port install name-of-package In our case we’ll be installing pandoc, so execute

sudo port install pandocInstalling MacTeX

Now you’ll need to install MacTeX, but don’t rush ahead just yet. You’ll soon notice that the generic MacTeX is approximately a 1.6GB download! That’s pretty hefty. Frankly, I didn’t feel like waiting around for such a huge package to download for such a small purpose. Instead, you can install the lighter package called BasicTeX, which is only 92MB (that’s more like it). Download and install the BasicTeX .pkg file. Finally, for pandoc’s markdown2pdf command to work you’ll need one additional package. Luckily, BasicTeX includes TeXLive which is a package manager for TeX packages (similar to Macports, which is also a package manager). First, update the package manager with sudo tlmgr update --self and then install the required package with sudo tlmgr install ucs Now you should be able to use the markdown2pdf command! You may need additional TeX packages for other commands. If so, just use the sudo tlmgr install name-of-package command.

blog/2011/04/12/vim-what-why-how/

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

conner mcdaniel about projects rss
Vim. What? Why? How?
APR 12TH, 2011
What?

Vim is a text editor, just like Notepad or TextEdit. At their most basic form, files can generally be interpreted as text depending on their encoding. Many files begin as text, not just .txt files. For example, the files that webpages interpret are composed by text in a language called HTML. Source code and configuration files begin as text before being compiled or read. Thus, text editors can be used to manipulate all of these files. Whether you want to make a quick grocery list or edit the configuration of your web server, you need a text editor.

Notepad and TextEdit are “GUIs” (graphical user interfaces). They are programs that you can move around on your desktop as a window. However, the people who wrote the original program called Notepad had to use something else to write it. They didn’t necessarily have a Desktop or windows to move around graphically. They may have coded it completely from the command line. Vim is such a program. It can edit files directly from the command line. It also has the ability to be used as a GUI like Notepad or TextEdit. The people who wrote vim also used something else to write it (probably a former counterpart of vim called vi), and so on until you finally get down to the actual hand-coded binary that was originally used to create the ability to edit text at all. However, because VI was used for years by developers, it gradually grew in features and efficiency.

Why?

Programmers are intelligent and efficient. In other words, programmers are lazy. They want to get in and out as fast as possible. This is exactly what vim is useful for. I’m not stating that vim is for everyone or that it’s easy to use, but there is no doubt about its speed in comparison to Notepad or TextEdit. Vim is basically a way to have keyboard shortcuts for anything you could possibly want to do to a text document. There are shortcuts for jumping to the end of a word, line, paragraph, or document. There are shortcuts for copy and pasting, finding and replacing, and opening or saving. You can view multiple documents at once in tabs or split screens, and there is a built-in file browser for navigating through your files. That being said, whenever you have that many key shortcuts there is going to be a learning curve. You must learn the shortcuts before you can reap all of vim’s benefits.

Because there is such a learning curve, the “why?” question is valid. Why should you waste your time with this? The answer is that you probably shouldn’t. Unless you do a lot of text editing, you probably don’t have a lot of use for vim. If you program, write blogs, configure servers, use the command line, or do a lot of technical writing then vim might be for you. Other options are either slower, too simple, too bloated or on the whole less elegant than vim. Vim is lightweight and fast. It doesn’t have a lot of bloated, built-in features. Instead it is an entire language of its own. If you learn this language, then you can tell it to do literally anything you want it to do (as far as editing text goes) with unlimited customization and unbeatable speed. You never have to reach for the mouse or look through lists of options again.

Let me give an example of what I mean by speed (better in full screen).

How?

Getting vim is easy. You can install it on any operating system either graphically, on the command line, or both. The downloadable files are found here. Learning vim takes a little more effort. The best way is to find an online tutorial that spells it out very simply. I found this reference to be very simple and useful as I was beginning. A more exhaustive reference can be found here.

blog/2011/10/12/using-vim-in-place-of-writeroom.html

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

Using vim in place of WriteRoom
Oct 12, 2011

Fullscreen editors, also called distraction-free editors, have become popular lately. It’s appealing to have nothing but the words you’re editing before you. However, these editors are often lacking some of the most elemental of features and sometimes cost money. Fortunately, it’s pretty easy to make MacVim into an exact replica of WriteRoom (or gVim into DarkRoom on Windows). Put the following into your .vimrc:

let g:writeroom = 0
let g:transparency = &transparency
function! WriteRoom()
if has(“gui_running”)
if g:writeroom == 0
let g:writeroom = 1
set columns=80
set fullscreen
set linebreak
set nocursorline
set nolist
set nonumber
set noshowmode
set rulerformat=%{strftime(‘%b %e %I:%M %p’)}
set transparency=0
hi NonText guifg=bg
else
let g:writeroom = 0
set cursorline
set list
set nofullscreen
set nolinebreak
set number
set rulerformat=
set showmode
let &transparency=g:transparency
hi clear
endif
endif
endfunction
This creates a function that you can execute to put MacVim into WriteRoom mode. If you don’t want the clock display then you can comment out the lines about rulerformat. Personally, I like to keep track of time when I’m in fullscreen mode. You can also change the lines and columns to best fit your screen size. Then, you can map a shortcut to execute the function. I use gw for normal mode and \w for insert mode.

nmap gw :exe WriteRoom()
imap w :exe WriteRoom()i
It’s pretty easy to make vim look however you want. If you happened to have some secret passion for notepad then it wouldn’t be difficult to make vim look that way either.

blog/2011/10/21/notetaking-with-vim.html

Notetaking with vim
Oct 21, 2011

Eventually I realized that Notational Velocity was just an extra keyboard shortcut and window on my desktop, so I ditched it for some better alternatives in vim. I’m especially fond of using ack and the ack plugin for vim. I’m using these mappings for my .vimrc

map n :e! /notes
map ] :Note
map [ :NoteTab
map 0 :Nls
command -nargs=1 Note :exe “e! ” . fnameescape(“/notes/.txt”)
command -nargs=1 NoteTab :exe “tabnew ” . fnameescape(“/notes/.txt”)
command -nargs=1 Nls :Ack –text “” /notes
I’ve also made some snippets to help with notetaking in markdown.

snippet img
![${1}](/notes/img/${2})${3}
snippet t
# `expand(“%:r”)`
> Date: `strftime(“%m-%d-%y”)`
> Instructor: ${1} `

## ${2}
The video also references my post about WriteRoom mode in vim.

blog/2012/05/20/pandoc-table-editing-in-vim.html

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

Pandoc table editing in vim
May 20, 2012

I’ve been itching for a way to get more efficient at creating pandoc tables ever since I started writing my notes in pandoc. Perhaps the only thing I’ve ever been jealous of emacs about is a video I saw using it’s orgtable mode. I haven’t quite adapted vim to work as emacs shows in this video. I’m convinced that it’s possible but also believe that the spreadsheet functionality shown is overkill. I don’t need my tables to do any math anyway; I just need them to be fast and seamless. To accomplish this, I turned to tabular. I originally got the idea while watching a vimcast on tabular that seemed to be behaving similarly to the emacs video. It uses a gist written by Tim Pope that executes :Tabularize every time you enter a pipe symbol. The code is provided in the show notes of the video, so you can easily copy that to your .vimrc. You can use this create a basic table structure dynamically, which ends up looking something like this:

| Fruit | Amount | Price | Total |
| Apple | 2 | $2.00 | $4.00 |
| Banana | 3 | $1.00 | $3.00 |
| Kiwi | 5 | $0.50 | $2.50 |
Well, that’s nice and all, but this is not a pandoc table. I wrote a simple (probably imperfect) function to convert this into a standard pandoc table:

Fruit Amount Price Total
—— —— —– —–
Apple 2 $2.00 $4.00
Banana 3 $1.00 $3.00
Kiwi 5 $0.50 $2.50
It works by visually selecting the lines and executing :Tabularize one last time in case there is any remaining misalignment.

vnoremap t :call table()
function! s:table() range
exe “‘<,'>Tab /|”
let hsepline= substitute(getline(“.”),'[^|]’,’-‘,’g’)
exe “norm! o” . hsepline
exe “‘<,'>s/-|/ |/g”
exe “‘<,'>s/|-/| /g”
exe “‘<,'>s/^| \\|\\s*|$\\||//g”
endfunction
There is another type of pandoc table, called a grid table. You can easily convert the markdown table into a grid table using pandoc itself like this:

command! -range=% Rst :’<,'>!pandoc -f markdown -t rst
Just select the pandoc table and run :Rst to convert it into a grid table like this:

+———-+———-+———+———+
| Fruit | Amount | Price | Total |
+==========+==========+=========+=========+
| Apple | 2 | $2.00 | $4.00 |
+———-+———-+———+———+
| Banana | 3 | $1.00 | $3.00 |
+———-+———-+———+———+
| Kiwi | 5 | $0.50 | $2.50 |
+———-+———-+———+———+

blog/2014/01/28/getting-things-done.html

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

Getting things done
Jan 28, 2014

Sometimes it’s difficult being productive. Procrastination can be a nasty problem. So, to help, I’ve made a simple script to keep me on track. It’s much like the pomodoro technique but without all the excess theory and pretense. It’s really just a command line egg timer that integrates with tmux, mpd, libnotify, espeak and any other custom commands you might like. It would not be difficult to extend its functionality either. The basic usage looks like this:

USAGE:

gtd [ -bcmnst ] [ work length ] [ break length ]

OPTIONS:

-b : start on a break
-c : custom command (defaults to “clear”)
-m : toggle MPD on change
-n : notify on change
-s : speak command
-t : show time in tmux status bar
The tmux integration really just updates a temporary file with the time remaining on the timer and refreshes your tmux session. You could use this in your tmux status bar like this for example:

set-option -g status-right “#(cat /tmp/gtd)#[fg=colour15,noreverse,bg=colour233] #(date ‘+%a %m/%d %I:%M %P’) ”
This sets the right side of your status bar to the time remaining in the timer (if the timer is on) and then the date and time. You could just as easily read this into conky or GeekTool (the OSX equivalent).

You can find the project here and add any suggestions to the issue tracker. Hope it helps someone else!

connermcd.com/blog/2013/03/11/easy-vim-session-management.html

Disclaimer: This content is not owned by the current webmaster nor do we claim the credit.  Ownership of this domain has changed hands. This URL however as a courtesy to web users is a  historic copy of what was originally published.

Conner Mcdaniel has created a new blog at https://connermcd.wordpress.com You can find all of his current publication there.

Easy vim session management
Mar 11, 2013

Until recently I haven’t really harnessed the power of vim’s session management capabilities. It can be a hassle somewhat to always use :mksession and :source, so I usually just neglect to do it; however, if you’re commonly working with large projects then it can be very useful to drop a session file into the root directory and make use of it. To aid me in utilizing this feature I added some customizations to my ~/.vimrc:

command! Mks let g:session = getcwd() call Mks(g:session)

augroup vimrc
au!
au BufRead *.session let g:session = expand(‘%:p:h’) | so % | bd #
au VimLeave * if exists(‘g:session’) | call Mks(g:session) | endif
augroup end

fun! Mks(path)
exe “mksession! “.a:path.”/”.fnamemodify(a:path, ‘:t’).”.session”
endfun
First, this sets a new custom user command called :Mks which will make a session file based on the current working directory. For instance, if :pwd is /home/connermcd/.bin/project/ then this will make a file inside that folder called project.session. It also sets a global variable (g:session) to the current working directory so that it can save the session here later. In the augroup a couple of autocommands are set. The first one (BufRead) executes when you open a file with the .session extension. This will set the g:session variable, source the session file, and delete it from the buffer list. The second one (VimLeave) executes when you close vim. If a g:session variable is found then it will override the session file with the new information. That’s pretty much it!

This works best if you aren’t using the autochdir option. I find that with it turned off it makes project navigation much more simple. Now when you create a new project just run the :Mks command to start session tracking, and when you want to access it later just open the .session file with vim.