Editor Note:
Read more about embedding games
Sunday, November 24, 2019
joenovell vs kalirajkvs: D20 Queen's Gambit Accepted • lichess.org
joenovell vs kalirajkvs: D20 Queen's Gambit Accepted • lichess.org:
Read more about embedding games
Read more about embedding games
Monday, April 15, 2019
Thursday, March 21, 2019
Thursday SUCESS
Embed in your website
<iframe src="https://lichess.org/embed/wguHcRFv?theme=auto&bg=auto"
width=600 height=397 frameborder=0></iframe>
Read more about embedding games
Accessibility: Enable blind mode
Free online Chess server. Play Chess now in a clean interface. No registration, no ads, no plugin required. Play Chess with the computer, friends or random opponents.
PLAY
LEARN
WATCH
COMMUNITY
TOOLS
joenovell
Reconnecting
lichess.org
∞ • Casual • Corresp.26 minutes ago
joenovell (1500?)
Stockfish AI level 1 (1350)
Checkmate • White is victorious
Spectator room
Notes
1 Spectators joenovell
12345678abcdefgh
Stockfish 10+WASM
in local browser
D30 Queen's Gambit Declined
1d4e62c4d53e3c64Bd3Nf65Nf3Ne46O-OBd67c5Bc78Nc3f59Nxe4fxe410Ne5O-O11Be2Nd712f3Nxe513dxe5Bxe514Rb1Bd715fxe4Qh416Rxf8+Kxf817Qf1+Kg818g3Qxe419Bd3Qa420Ra1Qb421Rb1Qxc522Qf3Qa523Qe2Qxa224Qh5Bd625Qxh7+Kf826Qh8+Kf727Qxa8Be728Qh8Qa529Qh5+Kf830Qh8+Kf731Qh5+Kf832Qe2Bf633Bd2Qa434b3Qa335Bc1Qe736Qf2Kg837Bd2Be838Bc1Bf739Bb2Bh540Rf1Kf841Bxf6Qb442Bc3+Kg843Bxb4g644Bf8e545Qf7+Kh846Qg7#
1-0
Checkmate, White is victorious
FEN
PGNDownload annotatedDownload rawEmbed in your website
[Event "Casual Correspondence game"]
[Site "https://lichess.org/wguHcRFv"]
[Date "2019.03.21"]
[Round "-"]
[White "joenovell"]
[Black "lichess AI level 1"]
[Result "1-0"]
[UTCDate "2019.03.21"]
[UTCTime "22:48:09"]
[WhiteElo "1500"]
[BlackElo "?"]
[Variant "Standard"]
[TimeControl "-"]
[ECO "D30"]
[Opening "Queen's Gambit Declined"]
[Termination "Normal"]
[Annotator "lichess.org"]
1. d4 e6 2. c4 d5 { D30 Queen's Gambit Declined } 3. e3 c6 4. Bd3 Nf6 5. Nf3 Ne4 6. O-O Bd6 7. c5 Bc7 8. Nc3 f5 9. Nxe4 fxe4 10. Ne5 O-O 11. Be2 Nd7 12. f3 Nxe5 13. dxe5 Bxe5 14. Rb1 Bd7 15. fxe4 Qh4 16. Rxf8+ Kxf8 17. Qf1+ Kg8 18. g3 Qxe4 19. Bd3 Qa4 20. Ra1 Qb4 21. Rb1 Qxc5 22. Qf3 Qa5 23. Qe2 Qxa2 24. Qh5 Bd6 25. Qxh7+ Kf8 26. Qh8+ Kf7 27. Qxa8 Be7 28. Qh8 Qa5 29. Qh5+ Kf8 30. Qh8+ Kf7 31. Qh5+ Kf8 32. Qe2 Bf6 33. Bd2 Qa4 34. b3 Qa3 35. Bc1 Qe7 36. Qf2 Kg8 37. Bd2 Be8 38. Bc1 Bf7 39. Bb2 Bh5 40. Rf1 Kf8 41. Bxf6 Qb4 42. Bc3+ Kg8 43. Bxb4 g6 44. Bf8 e5 45. Qf7+ Kh8 46. Qg7# { White wins by checkmate. } 1-0
Computer analysisMove timesFEN & PGN
0 Online friends
No friends online
Tuesday, March 19, 2019
Crowded Center Defense...
<iframe src="https://lichess.org/embed/ATtBhxyq?theme=auto&bg=auto"
width=600 height=397 frameborder=0></iframe>
Thursday, March 14, 2019
Test for Vaalerie
[Event "Rated Classical game"]
[Site "https://lichess.org/VWaZ3sjE"]
[Date "2019.03.15"]
[Round "-"]
[White "joenovell"]
[Black "exocube109"]
[Result "1-0"]
[UTCDate "2019.03.15"]
[UTCTime "02:02:09"]
[WhiteElo "1358"]
[BlackElo "1321"]
[WhiteRatingDiff "+10"]
[BlackRatingDiff "-10"]
[Variant "Standard"]
[TimeControl "1200+10"]
[ECO "E00"]
[Opening "Indian Game: East Indian Defense"]
[Termination "Normal"]
1. d4 Nf6 2. c4 e6 3. e4 c5 4. Nc3 Nc6 5. d5 exd5 6. exd5 Ne5 7. Be2 Qa5 8. Bd2 Bd6 9. Ne4 Qd8 10. Nxd6+ Kf8 11. Nf3 Nxf3+ 12. Bxf3 Qb6 13. Nxf7 Kxf7 14. b3 Qa6 15. Bg5 d6 16. Bxf6 Kxf6 17. O-O Re8 18. Re1 Bf5 19. Re3 g6 20. Qd2 b5 21. Be2 Rab8 22. g4 Be4 23. Qb2+ Kg5 24. Re1 Qa5 25. Rf1 bxc4 26. Bxc4 Re5 27. a4 Kxg4 28. Qe2+ Kg5 29. f4+ Kf6 30. fxe5+ Ke7 31. Rxe4 dxe5 32. Rxe5+ Kd6 33. Re6+ Kd7 34. Rf7+ 1-0
LiChess on Chessviews
<iframe src="https://lichess.org/embed/VWaZ3sjE#0?theme=auto&bg=auto"
width=600 height=397 frameborder=0></iframe>
Comment making in GitHub
<!DOCTYPE html>
<html>
<head>
<title>How to Comment in github</title>
<meta name="generator" content="BBEdit 12.6" />
</head>
<body>
tbaggery
tpope blogs here, when he blogs.
A Note About Git Commit Messages
19 Apr 2008
I want to take a moment to elaborate on what makes a well formed commit message. I think the best practices for commit message formatting is one of the little details that makes Git great. Understandably, some of the first commits to rails.git have messages of the really-long-line variety, and I want to expand on why this is a poor practice.
Here’s a model Git commit message:
Capitalized, short (50 chars or less) summary
More detailed explanatory text, if necessary. Wrap it to about 72
characters or so. In some contexts, the first line is treated as the
subject of an email and the rest of the text as the body. The blank
line separating the summary from the body is critical (unless you omit
the body entirely); tools like rebase can get confused if you run the
two together.
Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
or "Fixes bug." This convention matches up with commit messages generated
by commands like git merge and git revert.
Further paragraphs come after blank lines.
- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet, followed by a
single space, with blank lines in between, but conventions vary here
- Use a hanging indent
Let’s start with a few of the reasons why wrapping your commit messages to 72 columns is a good thing.
git log doesn’t do any special special wrapping of the commit messages. With the default pager of less -S, this means your paragraphs flow far off the edge of the screen, making them difficult to read. On an 80 column terminal, if we subtract 4 columns for the indent on the left and 4 more for symmetry on the right, we’re left with 72 columns.
git format-patch --stdout converts a series of commits to a series of emails, using the messages for the message body. Good email netiquette dictates we wrap our plain text emails such that there’s room for a few levels of nested reply indicators without overflow in an 80 column terminal. (The current rails.git workflow doesn’t include email, but who knows what the future will bring.)
Vim users can meet this requirement by installing my vim-git runtime files, or by simply setting the following option in your git commit message file:
:set textwidth=72
For Textmate, you can adjust the “Wrap Column” option under the view menu, then use ^Q to rewrap paragraphs (be sure there’s a blank line afterwards to avoid mixing in the comments). Here’s a shell command to add 72 to the menu so you don’t have to drag to select each time:
$ defaults write com.macromates.textmate OakWrapColumns '( 40, 72, 78 )'
More important than the mechanics of formatting the body is the practice of having a subject line. As the example indicates, you should shoot for about 50 characters (though this isn’t a hard maximum) and always, always follow it with a blank line. This first line should be a concise summary of the changes introduced by the commit; if there are any technical details that cannot be expressed in these strict size constraints, put them in the body instead. The subject line is used all over Git, oftentimes in truncated form if too long of a message was used. The following are just a handful of examples of where it ends up:
git log --pretty=oneline shows a terse history mapping containing the commit id and the summary
git rebase --interactive provides the summary for each commit in the editor it invokes
if the config option merge.summary is set, the summaries from all merged commits will make their way into the merge commit message
git shortlog uses summary lines in the changelog-like output it produces
git format-patch, git send-email, and related tools use it as the subject for emails
reflogs, a local history accessible with git reflog intended to help you recover from stupid mistakes, get a copy of the summary
gitk has a column for the summary
GitHub uses the summary in various places in their user interface
The subject/body distinction may seem unimportant but it’s one of many subtle factors that makes Git history so much more pleasant to work with than Subversion.
Comments disabled. Email me instead.
© Tim Pope Atom Feed
</body>
</html>
Tuesday, March 12, 2019
Test
tbaggery
tpope blogs here, when he blogs.
A Note About Git Commit Messages
19 Apr 2008
I want to take a moment to elaborate on what makes a well formed commit message. I think the best practices for commit message formatting is one of the little details that makes Git great. Understandably, some of the first commits to rails.git have messages of the really-long-line variety, and I want to expand on why this is a poor practice.
Here’s a model Git commit message:
Capitalized, short (50 chars or less) summary
More detailed explanatory text, if necessary. Wrap it to about 72
characters or so. In some contexts, the first line is treated as the
subject of an email and the rest of the text as the body. The blank
line separating the summary from the body is critical (unless you omit
the body entirely); tools like rebase can get confused if you run the
two together.
Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
or "Fixes bug." This convention matches up with commit messages generated
by commands like git merge and git revert.
Further paragraphs come after blank lines.
- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet, followed by a
single space, with blank lines in between, but conventions vary here
- Use a hanging indent
Let’s start with a few of the reasons why wrapping your commit messages to 72 columns is a good thing.
git log doesn’t do any special special wrapping of the commit messages. With the default pager of less -S, this means your paragraphs flow far off the edge of the screen, making them difficult to read. On an 80 column terminal, if we subtract 4 columns for the indent on the left and 4 more for symmetry on the right, we’re left with 72 columns.
git format-patch --stdout converts a series of commits to a series of emails, using the messages for the message body. Good email netiquette dictates we wrap our plain text emails such that there’s room for a few levels of nested reply indicators without overflow in an 80 column terminal. (The current rails.git workflow doesn’t include email, but who knows what the future will bring.)
Vim users can meet this requirement by installing my vim-git runtime files, or by simply setting the following option in your git commit message file:
:set textwidth=72
For Textmate, you can adjust the “Wrap Column” option under the view menu, then use ^Q to rewrap paragraphs (be sure there’s a blank line afterwards to avoid mixing in the comments). Here’s a shell command to add 72 to the menu so you don’t have to drag to select each time:
$ defaults write com.macromates.textmate OakWrapColumns '( 40, 72, 78 )'
More important than the mechanics of formatting the body is the practice of having a subject line. As the example indicates, you should shoot for about 50 characters (though this isn’t a hard maximum) and always, always follow it with a blank line. This first line should be a concise summary of the changes introduced by the commit; if there are any technical details that cannot be expressed in these strict size constraints, put them in the body instead. The subject line is used all over Git, oftentimes in truncated form if too long of a message was used. The following are just a handful of examples of where it ends up:
git log --pretty=oneline shows a terse history mapping containing the commit id and the summary
git rebase --interactive provides the summary for each commit in the editor it invokes
if the config option merge.summary is set, the summaries from all merged commits will make their way into the merge commit message
git shortlog uses summary lines in the changelog-like output it produces
git format-patch, git send-email, and related tools use it as the subject for emails
reflogs, a local history accessible with git reflog intended to help you recover from stupid mistakes, get a copy of the summary
gitk has a column for the summary
GitHub uses the summary in various places in their user interface
The subject/body distinction may seem unimportant but it’s one of many subtle factors that makes Git history so much more pleasant to work with than Subversion.
Comments disabled. Email me instead.
© Tim Pope Atom Feed
<!DOCTYPE html>
<html>
<head>
<title></title>
<meta name="generator" content="BBEdit 12.6" />
</head>
<body>
tbaggery
tpope blogs here, when he blogs.
A Note About Git Commit Messages
19 Apr 2008
I want to take a moment to elaborate on what makes a well formed commit message. I think the best practices for commit message formatting is one of the little details that makes Git great. Understandably, some of the first commits to rails.git have messages of the really-long-line variety, and I want to expand on why this is a poor practice.
Here’s a model Git commit message:
Capitalized, short (50 chars or less) summary
More detailed explanatory text, if necessary. Wrap it to about 72
characters or so. In some contexts, the first line is treated as the
subject of an email and the rest of the text as the body. The blank
line separating the summary from the body is critical (unless you omit
the body entirely); tools like rebase can get confused if you run the
two together.
Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
or "Fixes bug." This convention matches up with commit messages generated
by commands like git merge and git revert.
Further paragraphs come after blank lines.
- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet, followed by a
single space, with blank lines in between, but conventions vary here
- Use a hanging indent
Let’s start with a few of the reasons why wrapping your commit messages to 72 columns is a good thing.
git log doesn’t do any special special wrapping of the commit messages. With the default pager of less -S, this means your paragraphs flow far off the edge of the screen, making them difficult to read. On an 80 column terminal, if we subtract 4 columns for the indent on the left and 4 more for symmetry on the right, we’re left with 72 columns.
git format-patch --stdout converts a series of commits to a series of emails, using the messages for the message body. Good email netiquette dictates we wrap our plain text emails such that there’s room for a few levels of nested reply indicators without overflow in an 80 column terminal. (The current rails.git workflow doesn’t include email, but who knows what the future will bring.)
Vim users can meet this requirement by installing my vim-git runtime files, or by simply setting the following option in your git commit message file:
:set textwidth=72
For Textmate, you can adjust the “Wrap Column” option under the view menu, then use ^Q to rewrap paragraphs (be sure there’s a blank line afterwards to avoid mixing in the comments). Here’s a shell command to add 72 to the menu so you don’t have to drag to select each time:
$ defaults write com.macromates.textmate OakWrapColumns '( 40, 72, 78 )'
More important than the mechanics of formatting the body is the practice of having a subject line. As the example indicates, you should shoot for about 50 characters (though this isn’t a hard maximum) and always, always follow it with a blank line. This first line should be a concise summary of the changes introduced by the commit; if there are any technical details that cannot be expressed in these strict size constraints, put them in the body instead. The subject line is used all over Git, oftentimes in truncated form if too long of a message was used. The following are just a handful of examples of where it ends up:
git log --pretty=oneline shows a terse history mapping containing the commit id and the summary
git rebase --interactive provides the summary for each commit in the editor it invokes
if the config option merge.summary is set, the summaries from all merged commits will make their way into the merge commit message
git shortlog uses summary lines in the changelog-like output it produces
git format-patch, git send-email, and related tools use it as the subject for emails
reflogs, a local history accessible with git reflog intended to help you recover from stupid mistakes, get a copy of the summary
gitk has a column for the summary
GitHub uses the summary in various places in their user interface
The subject/body distinction may seem unimportant but it’s one of many subtle factors that makes Git history so much more pleasant to work with than Subversion.
Comments disabled. Email me instead.
© Tim Pope Atom Feed
</body>
</html>
Delivering COMMENTS - git it done---
tbaggery
tpope blogs here, when he blogs.
A Note About Git Commit Messages
19 Apr 2008
I want to take a moment to elaborate on what makes a well formed commit message. I think the best practices for commit message formatting is one of the little details that makes Git great. Understandably, some of the first commits to rails.git have messages of the really-long-line variety, and I want to expand on why this is a poor practice.
Here’s a model Git commit message:
Capitalized, short (50 chars or less) summary
More detailed explanatory text, if necessary. Wrap it to about 72
characters or so. In some contexts, the first line is treated as the
subject of an email and the rest of the text as the body. The blank
line separating the summary from the body is critical (unless you omit
the body entirely); tools like rebase can get confused if you run the
two together.
Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
or "Fixes bug." This convention matches up with commit messages generated
by commands like git merge and git revert.
Further paragraphs come after blank lines.
- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet, followed by a
single space, with blank lines in between, but conventions vary here
- Use a hanging indent
Let’s start with a few of the reasons why wrapping your commit messages to 72 columns is a good thing.
git log doesn’t do any special special wrapping of the commit messages. With the default pager of less -S, this means your paragraphs flow far off the edge of the screen, making them difficult to read. On an 80 column terminal, if we subtract 4 columns for the indent on the left and 4 more for symmetry on the right, we’re left with 72 columns.
git format-patch --stdout converts a series of commits to a series of emails, using the messages for the message body. Good email netiquette dictates we wrap our plain text emails such that there’s room for a few levels of nested reply indicators without overflow in an 80 column terminal. (The current rails.git workflow doesn’t include email, but who knows what the future will bring.)
Vim users can meet this requirement by installing my vim-git runtime files, or by simply setting the following option in your git commit message file:
:set textwidth=72
For Textmate, you can adjust the “Wrap Column” option under the view menu, then use ^Q to rewrap paragraphs (be sure there’s a blank line afterwards to avoid mixing in the comments). Here’s a shell command to add 72 to the menu so you don’t have to drag to select each time:
$ defaults write com.macromates.textmate OakWrapColumns '( 40, 72, 78 )'
More important than the mechanics of formatting the body is the practice of having a subject line. As the example indicates, you should shoot for about 50 characters (though this isn’t a hard maximum) and always, always follow it with a blank line. This first line should be a concise summary of the changes introduced by the commit; if there are any technical details that cannot be expressed in these strict size constraints, put them in the body instead. The subject line is used all over Git, oftentimes in truncated form if too long of a message was used. The following are just a handful of examples of where it ends up:
git log --pretty=oneline shows a terse history mapping containing the commit id and the summary
git rebase --interactive provides the summary for each commit in the editor it invokes
if the config option merge.summary is set, the summaries from all merged commits will make their way into the merge commit message
git shortlog uses summary lines in the changelog-like output it produces
git format-patch, git send-email, and related tools use it as the subject for emails
reflogs, a local history accessible with git reflog intended to help you recover from stupid mistakes, get a copy of the summary
gitk has a column for the summary
GitHub uses the summary in various places in their user interface
The subject/body distinction may seem unimportant but it’s one of many subtle factors that makes Git history so much more pleasant to work with than Subversion.
Comments disabled. Email me instead.
© Tim Pope Atom Feed
<!DOCTYPE html>
<html>
<head>
<title></title>
<meta name="generator" content="BBEdit 12.6" />
</head>
<body>
tbaggery
tpope blogs here, when he blogs.
A Note About Git Commit Messages
19 Apr 2008
I want to take a moment to elaborate on what makes a well formed commit message. I think the best practices for commit message formatting is one of the little details that makes Git great. Understandably, some of the first commits to rails.git have messages of the really-long-line variety, and I want to expand on why this is a poor practice.
Here’s a model Git commit message:
Capitalized, short (50 chars or less) summary
More detailed explanatory text, if necessary. Wrap it to about 72
characters or so. In some contexts, the first line is treated as the
subject of an email and the rest of the text as the body. The blank
line separating the summary from the body is critical (unless you omit
the body entirely); tools like rebase can get confused if you run the
two together.
Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
or "Fixes bug." This convention matches up with commit messages generated
by commands like git merge and git revert.
Further paragraphs come after blank lines.
- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet, followed by a
single space, with blank lines in between, but conventions vary here
- Use a hanging indent
Let’s start with a few of the reasons why wrapping your commit messages to 72 columns is a good thing.
git log doesn’t do any special special wrapping of the commit messages. With the default pager of less -S, this means your paragraphs flow far off the edge of the screen, making them difficult to read. On an 80 column terminal, if we subtract 4 columns for the indent on the left and 4 more for symmetry on the right, we’re left with 72 columns.
git format-patch --stdout converts a series of commits to a series of emails, using the messages for the message body. Good email netiquette dictates we wrap our plain text emails such that there’s room for a few levels of nested reply indicators without overflow in an 80 column terminal. (The current rails.git workflow doesn’t include email, but who knows what the future will bring.)
Vim users can meet this requirement by installing my vim-git runtime files, or by simply setting the following option in your git commit message file:
:set textwidth=72
For Textmate, you can adjust the “Wrap Column” option under the view menu, then use ^Q to rewrap paragraphs (be sure there’s a blank line afterwards to avoid mixing in the comments). Here’s a shell command to add 72 to the menu so you don’t have to drag to select each time:
$ defaults write com.macromates.textmate OakWrapColumns '( 40, 72, 78 )'
More important than the mechanics of formatting the body is the practice of having a subject line. As the example indicates, you should shoot for about 50 characters (though this isn’t a hard maximum) and always, always follow it with a blank line. This first line should be a concise summary of the changes introduced by the commit; if there are any technical details that cannot be expressed in these strict size constraints, put them in the body instead. The subject line is used all over Git, oftentimes in truncated form if too long of a message was used. The following are just a handful of examples of where it ends up:
git log --pretty=oneline shows a terse history mapping containing the commit id and the summary
git rebase --interactive provides the summary for each commit in the editor it invokes
if the config option merge.summary is set, the summaries from all merged commits will make their way into the merge commit message
git shortlog uses summary lines in the changelog-like output it produces
git format-patch, git send-email, and related tools use it as the subject for emails
reflogs, a local history accessible with git reflog intended to help you recover from stupid mistakes, get a copy of the summary
gitk has a column for the summary
GitHub uses the summary in various places in their user interface
The subject/body distinction may seem unimportant but it’s one of many subtle factors that makes Git history so much more pleasant to work with than Subversion.
Comments disabled. Email me instead.
© Tim Pope Atom Feed
</body>
</html>
Monday, February 4, 2019
Tuesday, January 29, 2019
Subscribe to:
Posts (Atom)
