text:
For information on current health and safety requirements, visit the Smith information page.
ProfileNewsThe DeanEquity, Diversity, Inclusion & IndigenizationLearning EnvironmentPartnerships Services SmithStore opens in new tab  Queen's University opens in new tab
Undergraduate Programs MBA Programs Graduate Programs Executive EducationInternationalSmithEdge
Smith Business Insight Research Publications Centres
Meet Our Faculty Join Our Ranks
Give to Smith Alumni
Recruit & Engage
Recruiting Partnerships Work with Students Smith Business Consulting
Back to Faculty
Executive Director (Analytics & AI Ecosystems) & Distinguished Professor of Management Analytics
stephen.thomas@queensu.ca
Academic:
Dr. Stephen W. Thomas is an adjunct faculty member at Smith School of Business at Queen's University in Kingston, ON, Canada. He is also the Executive Director of Smith's Analytics & AI Ecosystem. He was named the Professor of the Year in the MMA program in 2017 and 2018.
Download Full CV  Download Image
Academic Area
Management Analytics
Interest Topics
Profile Publications Teaching Awards Presentations Service
Dr. Thomas holds PhD, MSc, and BSc degrees in Computer Science. His main interests are databases, data analytics, and natural language processing. His research has been published in IEEE Transactions on Knowledge and Data Engineering, IEEE Transactions on Software Engineering, Empirical Software Engineering, and others. He is a recipient of the Scotiabank Scholar research grant.
Dr. Thomas previously ran a tech startup in the world of big data. He consults with several large companies in the areas of big data, text analytics, and AI. He previously held an industrial data analytics position at Raytheon in Tucson, AZ.
Dr. Thomas teaches several courses on natural language processing, machine learning, database design, big data, and mathematical analysis in Smith Commerce and MMA, and MMAI programs. He serves on the MMA advisory board.
PhD, Computer Science
Queen's University (2012)
MS, Computer Science
University of Arizona (2009)
BS, Computer Science
New Mexico State University (2006)
Smith School of Business, Queen's University
Executive Director, Analytics and AI Ecosystem (2021 - Present)
Director, Master of Management Analytics (2018-2020)
Director, Master of Management in Artificial Intelligence (2018-2020)
Adjunct Assistant Professor (2013 - Present)
School of Computing, Queen's University
Research Assistant (PhD Student) (2009-2012)
Refereed Papers
Chen, T., Thomas, S. W., Hemmati, H., Nagappan, M., and Hassan, A. E. (2017). An Empirical Study on the Effect of Testing on Code Quality Using Topic Models: A Case Study on Software Development Systems. IEEE Transactions on Reliability. 66(3): 806-824.
Chen, T., Shang, W., Nagappan, M., Hassan, A. E., and Thomas, S. W. (2016). Topic-based software defect explanation. Journal of Systems and Software. 129: 79-106.
Chen, T., Thomas, S. W., and Hassan, A. E. (2015). A survey on the use of topic models when mining software repositories. Empirical Software Engineering, 21(5): 1843-1919.
Barua, A., Thomas, S. W., and Hassan, A. E. (2014). What are developers talking about? An analysis of topics and trends in Stack Overflow. Empirical Software Engineering 19(3), 619–654.
Thomas, S. W., Adams, B., Hassan, A. E., and Blostein, D. (2014). Studying software evolution using topic models. Science of Computer Programming 80, 457–479.
Thomas, S. W., Hemmati, H., Hassan, A. E., and Blostein, D. (2014). Static test case prioritization using topic models. Empirical Software Engineering 19(1), 182–212.
Thomas, S. W., Snodgrass, R. T., and Zhang, R. (2014). Benchmark frameworks and tBench. Software: Practice and Experience 44(9), 1047–1075.
Thomas, S.W., Nagappan, M., Blostein, D., and Hassan, A.E. (2013). The impact of classifier configuration and classifier combination on bug localization. IEEE Transactions of Software Engineering 39(10), 1427–1443.
Bettenburg, N., Thomas, S. W., and Hassan, A. E. (2012). Using fuzzy code search to link code fragments in discussions to source code. In: Proceedings of the 16th European Conference on Software Maintenance and Reengineering.
Currim, F., Currim, S., Dyreson, C., Snodgrass, R. T., Thomas, S.W., and Zhang, R. (2012). Adding temporal constraints to XML Schema. IEEE Transactions on Knowledge and Data Engineering.
Snodgrass, R. T., Gao, D., Zhang, R., and Thomas, S. W. (2012). Temporal support for Persistent Stored Modules. In: Proceedings of the 28th International Conference on Data Engineering.
Thomas, S.W. (2011). Mining software repositories with topic models. In: Proceedings of the 33rd International Conference on Software Engineering, pp.1138–1139.
Thomas, S.W., Adams, B., Hassan, A. E., and Blostein, D. (2011). Modeling the evolution of topics in source code histories. In: Proceedings of the 8th Working Conference on Mining Software Repositories, pp. 173–182.
Thomas, S. W., Adams, B., Hassan, A. E., and Blostein, D. (2010). Validating the use of topic models for software evolution. In: Proceedings of the 10th International Working Conference on Source Code Analysis and Manipulation, pp. 55–64. Book Chapters
Snodgrass, R. T., Gao, D., Zhang, R., Thomas, S. W., and Dempsey, J. (2018). Temporal PSM. In: Encyclopedia of Database Systems. New York, NY: Springer.
Snodgrass, R. T., Thomas, S. W., and Zhang, R. (2018). tBench. In: Encyclopedia of Database Systems. New York, NY: Springer.
Dempsey, J., Snodgrass, R. T., Thomas, S. W., and Zhang, R. (2018). Temporal Benchmarks. In: Encyclopedia of Database Systems. New York, NY: Springer.
Thomas, S. W., Hassan, A. E., and Blostein, D. (2014). Mining unstructured software repositories. In: Evolving Software Systems, pp.139–162.
Thomas, S. W. (2012). Mining unstructured software repositories using IR models. PhD thesis. School of Computing, Queen's University.
Thomas, S. W. (2009). The implementation and evaluation of temporal representations in XML. Master's thesis. Department of Computer Science, University of Arizona.
Case Studies and Essays
Thomas, S.W. (2019). Using Text Analytics to Predict Loan Defaults: Kiva. Smith Living Case.
Thomas, S.W. (2019). Assembling the AI Dream Team. Smith Business Insight.
Thomas, S.W. (2017). Advanced Analytics at SCENE. Smith Living Case.
Thomas, S.W. (2012). Mining software repositories with topic models. Technical report 2012-586. School of Computing, Queen's University.
Thomas, S. W., Snodgrass, R. T., and Zhang, R. (2010). tBench: Extending XBench with time. Technical report TR-93. TimeCenter.
June 11, 2019. AI in Business. Proof Lunch and Learn. Toronto, ON, Canada.
May 7, 2019. AI and Smith. Presentation to the Smith Global Council. New York, NY, USA.
February 4, 2019. AI and Smith. Presentation to the Smith Global Council. London, UK.
November 30, 2012. PhD thesis defense. Mining unstructured software repositories using IR models. Kingston, ON, Canada.
December 9, 2011. Presentation for School of Computing Open House. Effective bug localization. Kingston, ON, Canada.
December 10, 2010. Presentation for School of Computing Open House. Statistical topic models. Kingston, ON, Canada.
March 6, 2009. Master's thesis defense. The implementation and evaluation of temporal representations in XML. Tucson, AZ, USA.
Murray, Seb. "Should I do a Specialized Business Master's Program?" MiM Guide. June 14, 2019.
Titleman, Naomi. "How to address the rise of AI technology in the world of work." Globe and Mail. May 13, 2019.
Titleman, Naomi. "Robot to human: Help me help you." Globe and Mail. May 13, 2019.
Toneguzzi, Mario. "Technology sector increasingly attractive for Calgary workers." Calgary Business. March 12, 2019.
Flexhaug, Dallas. "Energy workers turn to tech jobs." Global News Morning. Global News. February 25, 2019.
Rosa Saba. "Energy workers are willing to switch to tech, survey finds – and experts say it's time for Calgary to 'take the lead.'" The Star Calgary. Feb 21, 2019.
Whelan, Audrey. "How Calgarians can pivot their careers towards technology."660 News Calgary. February 13, 2019.
Lawrence, Daina. "Business and artificial intelligence come together in new program." The Globe and Mail.December 20, 2018.
"How Calgary can become an innovation hub." Global News Radio. Newstalk 770 Calgary. November 2, 2018.
Nilsson, Patrica. "Business schools bridge the artificial intelligence skills gap." Financial Times. September 12, 2018.
"… with Artificial Intelligence in Business?" What on Earth is Going on? June 29, 2018.
Mark, Corey. "Why Do A Master Of Management In Artificial Intelligence?" BusinessBecause. June 7, 2018.
"Is Artificial Intelligence really more dangerous than a nuke?" The Morning Show. Global News. March 12, 2018.
Ethier, Marc. "Queen's Launches 1st-Of-Its-Kind AI Degree." Poets & Quants. March 12, 2018.
"The First Master's Program in Artificial Intelligence." Gormley. 650 CKOM Saskatchewan. March 9, 2018.
Greiner, Lynn. "IBM and Queen's University Smith School of Business unveil five-year partnership with the Cube." Financial Post. March 24, 2017.
"In AI, There are No Magical Unicorns." Smith Business Insight. June 5, 2019.
Montgomerie, Adrienne. "Hack the Language of Loan Defaults." Smith Business Insight. April 2, 2019.
Montgomerie, Adrienne. "Ping! Click! How One Mega-Mall Finds Its Big Data Edge." Smith Business Insight. March 26, 2019.
"Smith welcomes inaugural MMAI class." Smith News. September 28, 2018.
Gerlsbeck, Rob. "The AI Manager." Smith Magazine. Summer 2018.
Pabla, Jasnit. "Artificial Intelligence comes to the Smith School of Business." The Queen's Journal. March 23, 2018
"Students look to solve global food security at Queen's challenge." Smith News. December 12, 2017.
March 13, 2019. Chatbots: Technology and Trends. Smith Insight.
September 11, 2018. AI and Management Come Together in the Classroom at Queen's University. Big Data Beard Episode 42.(YouTube)
July 3, 2018. Recommender Systems: Overview and Case Studies. Smith Insight.
May 17, 2018. Building AI Bench Strength. Smith Insight.
August 29, 2017. Data Analytics: An Overview. United Nations World Food Program ICT Workshop. Panama (Webinar).
June 29, 2017. Data Analytics: An Overview. United Nations World Food Program ICT Workshop. Johannesburg, South Africa (Webinar).
Commerce, Smith School of Business, Queen's University
COMM 161: Introduction to Mathematical Analysis for Management. Fall 2013.
COMM 492: Managing Data for Business Intelligence. Winter 2014. Fall 2014. Fall 2015. Fall 2016. Fall 2017.
Master of Management Analytics, Smith School of Business, Queen's University
MMA 865: Big Data. 2017. 2018W. 2018S. 2019W. 2019S.
MMA 869: Machine Learning and AI. 2019S. 2020W.
Text Analytics and Sentiment Analysis. 2015. 2016. 2017. 2018W. 2018S. 2019W.
Master of Management in Artificial Intelligence, Smith School of Business, Queen's University
MMAI 869: Machine Learning and AI. 2019. 2020.
MMAI 891: Natural Language Processing. 2019. 2020.
Executive MBA Americas, Smith School of Business, Queen's University/Cornell University
NBAB5950-MBQC960: Big Data Analytics. 2019. 2020.
Summer Enrichment Program, Smith School of Business, Queen's University
MBQC960: Big Data Analytics. 2019.
Master of Business Administration, Smith School of Business, Queen's University
MBAS 862: Text Analytics. Fall 2019.
Queen's Executive Education
Text Analytics and Sentiment Analysis. 2015-2016
Big Data and Text Analytics. 2017-
Digital Transformation. 2019-
AI Essentials for Managers. 2019-
Co-supervisor, Cecilia Ying. Topic TBD. 2019 –
External examiner, Julianne Jakobek. You Are Never Alone with a Robot: A Qualitative Content Analysis on the Use of Anthropomorphic Technologies. 2019.
External examiner, Kristopher Jones. Toward a Political Sociology of Blockchain. 2018.
Co-supervisor, Arnoosh Golestanian, Conflict Analytics Lab. 2019.
Co-supervisor, Karandeep Singh. Analytics at iTrade. 2019.
Co-supervisor, Neal Gilmore. Conflict Analytics Lab. 2019.
Co-supervisor, Ross Couldrey. Analytics at iTrade. 2018-2019.
Supervisor, Imad Ghani. Conflict Analytics Lab. 2018-2019.
Supervisor, Sargon Morad. Analytics and AI at Oxford Properties. 2018-2019
Supervisor, Sarah Scott. Analytics at SCENE. 2018
Co-supervisor, Arnoosh Golestanian, Analytics and AI at BGIS. 2018
Supervisor, Yue Zhou. Analytics at SCENE. 2017-2018
Supervisor, Ninad Parab. Analytics at SCENE. 2017
Co-supervisor, Amir Emami Gohari. Interpretation of Black-box Models. 2017
Guest Lectures and Workshops
September 12, 2019. Introduction to NLP. Queen's Law School. Kingston, ON, Canada.
June 17, 2019. Artificial Intelligence and Machine Learning – what is it all about? Surveillance Studies Summer Seminar. Kingston, ON, Canada.
May 15, 2019. AI in Business. Smith Executive MBA Alumni Event. Kingston, ON, Canada.
April 2, 2019. AI in Business. Smith Centre for Social Impact. Kingston, ON, Canada.
November 27, 2018. Overview of AI and NLP. Queen's Law School. Kingston, ON, Canada. Conference Presentations
August 20, 2012. Mining unstructured software repositories. Poster. MSR 2020 Vision. Kingston, ON, Canada.
June 21, 2011. Mining software repositories with topic models. Poster. ICPC 2011. Kingston, ON, Canada.
June 17, 2011. Mining software repositories with topic models. Poster. PASED 2011. Montreal, QB, Canada.
May 23, 2011. Mining software repositories with topic models. ICSE 2011. Honolulu, HI, USA.
May 22, 2011. Modeling the evolution of topics in source code histories. MSR 2011. Honolulu, HI, USA.
September 12, 2010. Validating the use of topic models for software evolution. SCAM 2010. Timisoara, Romania.
2019. MMA Professor of the Year (Class of Summer 2019)
2019. MMA Professor of the Year (Class of Winter 2019)
2016–present. Scotiabank Scholar, Smith School of Business, Queen's University
2009–2012. Queen's Graduate Award Scholarship, Queen's University
2009. Advanced Scholarship Program, Raytheon Missile Systems
2009. Graduate Tuition Scholarship, University of Arizona
2004–2006. Crimson Scholar, New Mexico State University
2004–2006. Dean's List, New Mexico State University
2005–present. Member, Pi Mu Epsilon, New Mexico State University
June 19, 2019. Building the AI Dream Team. Vector's AI for Executives. Toronto, ON, Canada.
June 13, 2019. The New Manager: The Growing Need for Analytics & AI Managers. What AI Can Do to Drive Your Business Forward. HEC Montreal. Montreal, QB, Canada.
June 12, 2019. The New Manager: The Growing Need for Analytics & AI Managers. Big Data and AI conference. Toronto, ON, Canada.
May 3, 2019. AI and Big Data. Canadian University Board Association Conference. Kingston, ON, Canada.
March 9, 2019. AI Transforming Industry. Panel moderator. Canadian Undergraduate Conference on Artificial Intelligence. Kingston, ON, Canada.
March 6, 2019. Machine Learning in the Financial Industry. Panel member. CPA Ontario. Toronto, ON, Canada.
December 10, 2018. Building Analytics and AI Bench Strength. SLF Analytics Conference. Toronto, ON, Canada.
November 7, 2018. AI and the Future of Extraction Industries. Becoming Future Proof. Calgary, AB, Canada.
August 28, 2018. AI and Analytics for Business. Disney Data & Analytics Conference 2018. Orlando, FL, USA.
June 6, 2018. Recommender Systems: Overview and Three Case Studies. Smith/Vector Presents: AI for Execs. Toronto, ON, Canada.
May 17, 2018. AI and Analytics in Business. Machine Learning & Artificial Intelligence Ottawa. Ottawa, ON, Canada.
May 11, 2018. Building the Next Generation of Analytics Talent. Analytics by Design. Toronto, ON, Canada.
May 2, 2018. Advanced Analytics at SCENE. Queen's Data Day. Kingston, ON, Canada.
April 18, 2018. Analytics and AI in Business. Council for Chief Privacy Officers: Emerging Technologies and Privacy. Toronto, ON, Canada.
October 23, 2017. Machine Learning and Analytics. Smith in Calgary (Alumni Event). Calgary, AB, Canada.
September 6, 2017. Artificial Intelligence. Smith Graduate Student Consortium. Roundtable Discussion. Kingston, ON, Canada.
July 24, 2017. Harnessing the Power of Data Analytics within Your Organization. Chief Learning Officer Exchange. Toronto, ON, Canada.
June 1, 2017. Sentiment Analysis: Opportunities, Challenges, and the Future. Queen's Analytics Institute Workshop. Kingston, ON, Canada.
April 19, 2017. The Analytics Mindset. Scotiabank's Finance Learning Day. Toronto, ON, Canada.
March 13-14, 2017. A Strategic Analytics Framework. United Nations Data Innovations Lab Workshop. Nairobi, Kenya.
November 7, 2012. Effective bug localization. IBM CASCON 2012. Markham, ON, Canada.
October 15, 2012. Mining unstructured data. Panelist member. Mining Unstructured Data 2012. Kingston, ON, Canada.
Member, Queen's University Alterative Assets Fund (QUAAF) Executive Board, 2019–
Executive Advisor, Analytics By Design Conference, 2018–
Member, Queen's MMAI Faculty Development Fund committee, 2018–
Member, Queen's Master of Management Analytics Curriculum Review Committee. 2017.
Member, Queen's Master of Management Analytics Advisory Board. 2016–
Conference Reviewer: MSR Challenge 2013
Journal co-reviewer: IEEE Transactions on Software Engineering, Software: Practice and Experience
Conference co-reviewer: MSR Challenge 2012, MSR 2012, ICSE 2012, CASCON 2011, WCRE 2011, ESEM 2011, MSR 2011, ICSM 2010, WCRE 2010, GI 2010, MSR 2010
Research Affiliations
Data Scientist, The Conflict Analytics Lab. 2018–
Scholar, the Scotiabank Centre for Customer Analytics. 2016–
2010–present. Member, ACM Special Interest Group on Software Engineering (SIGSOFT)
2008–present. Member, Association for Computing Machinery (ACM)
2008–present. Member, Institute of Electrical and Electronics Engineers (IEEE)
Goodes Hall
Canada K7L 3N6
Simcoe Place
Smith Centres
Smith Services
Connect with Smith
The Smith School of Business Kingston campus is situated on traditional Anishinaabe and Haudenosaunee Territory.
SmithToronto is situated on the traditional territory of the Huron-Wendat and Petun First Nations, the Seneca, and the Mississaugas of the Credit River.
© Smith School of Business


The Green & White Ice Hockey elbow pad has been designed with improved and enhanced design that assures maximum safety from injuries. The materials used in this protective gear are very sturdy yet lightweight which makes it very easy to wear them. The unrestrictive elastic ensures proper blood flow while keeping the elbow pads secured in their place.


text:
Migos Back In The Studio For New Album???
Welp, looks like the 3 Amigos are back in the lab together working on some new music. According to sources Offset 1/3 of the Migos "its up for 2021" leading many fans to believe that they could very well be gearing up to drop something new in the upcoming year. Culture II was the latest full album the group dropped in 2018. Posts from Offset also may confirm that the 3 are steady working.
Side bar if you were ever wondering if the 3 were fans of Chick-fil-a wonder no more.

redpajama_set_name: RedPajamaCommonCrawl


text:
Aldaier Makatindu (born 25 May 1992) is an Indonesian professional footballer who plays as a forward.

Career
On January 14, 2015, he signed with Borneo Samarinda.

International goals
International under-23 goals

Honours

Club
Persisam Putra Samarinda U-21
 Indonesia Super League U-21 runner-up: 2012

International
Indonesia U-23
 Islamic Solidarity Games  Silver medal: 2013

Individual
 Indonesia Super League U-21 Top Goalscorer: 2010–11, 2012

References

External links

 Aldaier Makatindu at Liga Indonesia

1992 births
Living people
Sportspeople from Jakarta
Indonesian footballers
Liga 1 (Indonesia) players
Persisam Putra Samarinda players
Borneo F.C. players
Footballers at the 2014 Asian Games
Association football forwards
Asian Games competitors for Indonesia

redpajama_set_name: RedPajamaWikipedia


text:
Thecla centuncula är en fjärilsart som beskrevs av Max Wilhelm Karl Draudt 1920. Thecla centuncula ingår i släktet Thecla och familjen juvelvingar. Inga underarter finns listade i Catalogue of Life.

Källor

Juvelvingar
centuncula


The Onsrud 63-606 CNC Router Bit is used to cut Aluminum. This router bit has a upcut polished spiral O flute for a smooth finish, with an overall length of 2". The cutting diameter is 1/8" and the cutting length is 1/4". The bit also has a Flute/Helix degree of 22.
The 63-606 is a best seller for CNC Applications.


text:
[![Build Status](https://travis-ci.org/rudyyazdi/site.svg?branch=master)](https://travis-ci.org/rudyyazdi/site)
# rudyyazdi.github.io
My Personal Website

# clone

git clone --recursive git@github.com:rudyyazdi/site.git

redpajama_set_name: RedPajamaGithub


text:
Midgettes take two from Eagles
By Staff | Jun 7, 2008
EAGLE GROVE — In place of a two-day tournament in Webster City, the Estherville Lincoln Central softball team played a doubleheader against Eagle Grove on Friday.
The Midgettes took game one 9-1 and game two 8-2 to improve to 11-2 on the season.
In game one, ELC led 8-0 before Eagle Grove got on the board.
Offensively, Erin Beardsley's two-run home run in a four-run fourth inning highlighted the night.
She was 3-4 with three RBIs while melanie Bandow was 3-5 with three RBIS and Maggie Asman was 2-2 with two RBIS. Also Taylar Jacobson was 2-3.
Amanda Christensen made the game a little easier for her defense as she struck out 13 batters. She also walked three and gave up three hits.
Host Eagle Grove took an early 1-0 lead in game two, but ELC tied the game in the third and plated three runs in the fourth to take a 4-1 lead.
Although Eagle Grove got one back in the bottom of the inning, the Midgettes scored the final four runs of the game.
"We hit the ball well with and had solid pitching and catching," said ELC assistant coach Molly Reuland. "It was a good day."
At the plate, Brenna Wegner was 4-4 with two doubles and Maggie Asman was 2-3 with two RBIs. Melanie Bandow was 1-4 with an RBI and Brooke Egeland also had an RBI.
Egeland pitched four innings to pick up the win. She struck out two, walked one and gave up two hits. Kendall Bosch closed out the game, striking out five batters while giving up two hits and a walk.
ELC plays at the one-day Webster City Tournament today. At 11 a.m., ELC plays Fort Dodge followed by Carroll-Kuemper at 12:30 p.m.
ELC	102 410 1 – 9 12 1
Eagle Grove	000 010 0 – 1 3 4
ELC – Christensen (WP) and Juergens, Beardsley (6). EG – Jeske (LP) and Locke. HR – Beardsley.
ELC – Egeland (WP), Bosch and Juergens. EG – Erickson(LP) and Choquette. 2B – Wegner 2.
ELC comes up with answers to beat Tigers
Midgets unable to keep up with Tigers
ICCAC Honors Iowa Lakes Student Athletes
Iowa Lakes athletes were recently honored by the Iowa Community College Athletic Conference (ICCAC) for academic ...


Yay! It's the first day of (30) Days of Sundresses and I get to kick it off. Today I'm sharing this bow back dress tutorial.
Thanks to our awesome (30) Days of Sundress Sponsors – Baby Lock Sewing and Embroidery, and this week's giveaway sponsor Raspberry Creek Fabrics – go here to enter for a chance to win a $50 store credit.
We have a wedding to go to this summer. Well, fall really, but September is still summer weather in Texas. It's a wedding that's been a long time coming – my brother-in-law is finally marrying the girl he's been with for almost a decade. Anyone else get to go to one of those kind of weddings? We're pretty excited, and the boys will be dual ringbearers again. And I love to sew dresses for weddings, so this one is a definite contender. That is, if it doesn't get worn out before then.
For the back bodice, which usually doesn't have a dart, all you have to do is draw in the A line for the skirt, and cut out the opening on the back. Drop a line straight down from the shoulder point and curve in a few inches above the waist.
To make the dress, start by sewing the shoulders and side seams, right sides together.
To finish the edges you'll need bias tape or, if you're using a knit like I did, knit fabric reinforced with knit interfacing to use similarly to bias tape. Your knit tape should still stretch. You want the knit interfacing to keep the armholes/back neck from sagging under the weight of the fabric and stretching your neckline down to reveal more than you want.
Sew the bias tape or knit interfaced tape around the neckline, right sides together. You want to stretch around the curviest parts in the back and the front. This is so that when you fold the tape over it doesn't wrinkle up on the inside edge.
Sew tape around the armholes, right sides together as well, stretching the tape slightly, but not the fabric.
Fold the bias tape or knit tape to the wrong side of the fabric, folding the raw edge under, and stitch close to the edge. The WRONG side of the dress is shown below.
To make the bow, I cut a 10″ x 10″ square. You may want to make your bow piece wider depending on the size of your back opening. Fold it right sides together and stitch around two sides.
Use the open side to turn the bow right side out. Press, then press the raw edges to the inside. Topstitch around the bow to close the opening.
Pin the bow piece over where your bra strap goes – you may need to try this on to check. Measure from each shoulder seam down the neckline to make sure you have the bow piece sitting even.
On the inside of the dress, hand stitch the edges of the bow in place, sewing only through the bottom layer of the bow.
Cut a tube about 3 inches wide and 3 inches long. Fold in half, right sides together, and stitch down one edge. Turn tube right side out. Sew a snap onto the ends of the tube so that when you close the snap it forms a ring. Since I used knit fabric I didn't worry about finishing the ends of my tube, but if you are using woven you can push the raw edges to the inside and topstitch closed like you did for the bow piece.
Snap the tube around the bow center to form the bow. When you wear the dress, you'll snap this around your bra strap, making sure everything stays in place.
Add a big hat and some flowers and you're styled to go!
Don't forget to come back tomorrow – we've got a giveaway from Raspberry Creek Fabrics and a new tutorial from One Little Minute.
This has beautiful drape to it. And really quite simple to sew.
I love Love LOVE this! …and the snap piece to keep your bra strap in check? Fantastic idea!
The dress….is just so doggone cute!!!!! And I love the look.
Thanks for one of the best and most simple summer dresses I have seen yet this year. Even with what I have seen out in the stores! I love it!
Love so much!! What weight knit did you use??
Snapping the tube around the bra strap is genius!
LOVE!!!!! It is simply gorgeous on you!
So great! Totally genius the way it snaps around your bra strap. I'm so excited to see all of these dresses this month! Whew!
About how much fabric does this cute little dress require?
This is such a cute dress! Simple, easy, quick – my three favorite words when it comes to sewing for summer. I have used the bow across the back to hide the bra trick, but not recently. I see a new sundress in my future. Thanks for taking time to share. Great job!
Muy bueno el vestido. Facil y nada complicado para hacerlo.
I've been given 2 lots of lightweight material which I'll make this dress with – but reversible, so no slip required. And I can make two bows so I can have a contrast or matching one. So pretty, I've been wondering what pattern to use as we are coming into hot weather. Thanks so much.
This is brilliant.Thank you for sharing!
This dress is soooooo cute! I love how you could still wear a bra with it but you get all the fun of the backless dress. Plus, your tutorial is awesome. How cute would this be in black and white?! I'll be trying this out this weekend!


I absolutely loved this wonderf8ul book. I love a good historical romance and this is one of the best ones. The characters were intriguing and the prose so engaging, this was a one sit read for me. I would recommend it to everyone who reads romance. This was a roller-coaster ride of adventure, romance and emotions. This was my first book by the author and I really look forwarded to reading more.
Rowena Emerson studied her longtime friend, Evan Barnes, and tried to judge by his expression if he'd be game for a new scheme. It was hard to tell; he had come home from the war a mysterious stranger, with only glimpses of his former playful self who had always been ready for a new lark.
Of course, two family deaths in as many years, not to mention all he'd suffered during war, would subdue even the liveliest spirit. Still, perhaps Evan's old personality could be coaxed into returning. A diverting new mission might be just the thing to draw him out. Besides, if this plan worked, their parents would find happiness. her Silent and rigid as a soldier, Evan made no move, except his eyes while other members of the dinner party laughed and conversed in the drawing room. Was he glad he'd come home or did he long to return to aid his countrymen in the ongoing war against Napoleon?
"Oh, pish. You only fell a short distance, and it was worth it. Besides, I concocted several diverting ideas while you were gone, and no one fell to his death." She leaned forward and peered into his face. Are you still there? she longed to ask.
From the publisher of the USA TODAY bestselling & #1 Amazon bestselling Timeless Romance Anthology series in Clean & Wholesome Romance, comes the Timeless Romance Singles line.
THE MATCHMAKING GAME: A brand new historical romance novella from bestselling author Donna Hatch.
Rowena's childhood friend, Evan, has returned home from war a handsome, but mysterious stranger. In an effort to bring happiness to her father, not to mention uncover the Evan she remembers from their youth, Rowena seeks to unite their parents. Who better to match a lonely widow and widower together than their adoring children? Her matchmaking game could help their parents find happiness and draw out her childhood friend buried beneath Evan's new reserve … or it could break more than one heart.
Thank you so much for sharing this excerpt from my book!


text:
Тайо (авіаносець), Тайо (яп. 大鷹) — японський ескортний авіаносець часів Другої світової війни, тип «Тайо».
 Ескортні авіаносці типу «Тайо» ()  — серія японських ескортних авіаносців часів Другої світової війни.


text:
namespace boost { namespace numeric {

    template <>
    struct numeric_cast_traits
        <
            char
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int8_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint8_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int16_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint16_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int32_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint32_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::int64_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::uint64_t
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::int8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::uint8_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint8_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::int16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::uint16_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint16_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::int32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::uint32_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint32_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::int64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::int64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::uint64_t
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::uint64_t> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

}}


Looks absolutely stunning! Did you do all the art in Aseprite?
Yeah, Asesprite all the way.
Red, that water effect would have been gorgeous enough but tying it into a dungeon generator is just beyond beautiful. The HID sits well on the screen too I think.
Are you using the built-in generator of RM2k3?
Nah, it's not the built in one, it's so terrible. Tried it a couple of times but never gotten anything usable from it.
Built my own since I want to generate the maps in run time.
It'd be nice to see how you built it, it might be useful for people who try random dungeons.
I've made one when Tower was still a thing, but it was far from perfect and the project died before I finished the generator.
Can send you the project if you want. But be warned the generator is kinda messy and hacked together.
Since I'm back with my computer again I've been meaning to try this. Are you far away from a release of the fancy version?
Nah, not close. Not sure I'm going to finish it actually don't have a good idea for the story and not too happy with the battle system. Maybe I'll redo it or maybe I'll move onto something else. Haven't decided yet.
Kind of just echoing what everyone else has already said, but this is gorgeous. Kuest 1.5 looks a lot more like Kuest 2. Even if you don't finish it, I think that companion system tied with the battle system and dungeon crawling is a winning combination, I'm not so sure you really need to worry about a storyline with gameplay like that.
Yeah, kind of tempted to change it to be more like 1, just a puzzle rpg thing. It was the original plan but the more I worked on it the more it started to morph into something more akin of a standard rpg.


text:
Q: Getting "all" itineraries for a specific timeframe out of OpenTripPlanner in a single request Following the tutorial I set up an OpenTripPlanner 2.0.0 server with the Portland area for routing requests. Now I would like to compile a collection of many possible itineraries.
By default I get around 3-4 itineraries by request. E. g. http://localhost:8080/otp/routers/default/plan?fromPlace=45.51789504294005%2C-122.52365112304688&toPlace=45.49575902279182%2C-122.61772155761719&time=7%3A35pm&date=07-23-2021&mode=TRANSIT%2CWALK&maxWalkDistance=4828.032&arriveBy=false&wheelchair=false&debugItineraryFilter=false&locale=en as requested by the browser when using the example GUI will return 3 alternative itineraries.
How can I make OpenTripPlanner return all suitable itineraries for a whole day?

A: You can simply add the parameter &numItineraries=x (where x is an integer) to your request URL to specify the maximum number of route options to return. Note that this sets the maximum, if there are less options, you will get fewer routes than specified here.
So if you for example want to return 7 options, your URL will look like this:
http://localhost:8080/otp/routers/default/plan?fromPlace=45.51789504294005%2C-122.52365112304688&toPlace=45.49575902279182%2C-122.61772155761719&time=7%3A35pm&date=07-23-2021&mode=TRANSIT%2CWALK&maxWalkDistance=4828.032&arriveBy=false&wheelchair=false&debugItineraryFilter=false&locale=en&numItineraries=7
If you want all trips for a whole day by TRANSIT,WALK I suggest to fire several requests (e.g. in a loop) with different &time parameters instead of using a very high number of itineraries.

redpajama_set_name: RedPajamaStackExchange


text:
Return to Celebration Week
Nathan Chen
A Two-Time World Champion (2018 & 2019), 2018 Olympic Bronze Medalist in the Team event, Three -Time U.S. Champion (2017-2019), Two-Time Grand Prix Final Champion (2017 & 2018), Nathan Chen has literally taken figure skating to new heights. The two-time World Champion and three-time United States Champion has made winning a habit. He became the first skater to land five quadruple jumps in one program and was the first skater to ever attempt six quads in one program. He accomplished this on the sport's biggest stage – at the 2018 Winter Olympic Games.
Nathan, who was born in Salt Lake City, home of the 2002 Winter Olympics, had always dreamed about competing at the Olympic Games. He was even interviewed on TV at the age of ten hoping to be able to compete in the 2018 Olympics. Nathan started skating when he was just three years old and has made a rapid rise in the sport. He won two national titles at the novice level (he became the youngest national novice champion at the age of ten) and captured two more national titles at the junior level before moving up to the senior ranks.
At the 2016 U.S. Championships in St. Paul, he became the first U.S. skater to land two quads in a short program. Then he closed out the event by landing four quads in the free skate. Nathan's jumping prowess helped him enter the record books, as the previous record number of quads landed in a long program was three. Nathan, unfortunately, suffered a hip injury at the 2016 U.S. Championships exhibition that required surgery. He spent five months in rehabilitation at the Olympic Training Center in Colorado Springs, Colorado. Nathan feels that this recovery made him mentally and physically stronger. He proved it with his 2016 Grand Prix Final Silver Medal performance in Marseilles, France.
At the 2017 U.S. Championships in Kansas City, Nathan earned a record-breaking score of 106.39 in the short program, setting a new U.S. record by more than six points. He ignited the crowd with a record five clean quadruple jumps in the free skate, sending a message to the best skaters in the world that he had indeed emerged as the new quad king. Nathan became the youngest U.S. men's champion in more than five decades.
Nathan won every competition he entered leading up to the 2018 Olympic Winter Games, earning gold medals in both of his international Grand Prix events and the Grand Prix Final. Nathan defended his U.S. crown at the 2018 U.S. Championships in San Jose and was selected to compete in his first Olympic Games.
The 2018 Winter Olympics did not go quite as Nathan had hoped. After the short program, Nathan was in 17th place. The next day, Nathan came back with a vengeance. His incredibly demanding free skate program registered the highest score in the free skate (215.08 points), beating the score of eventual Olympic gold medalist Yuzuru Hanyu by 8.91 points. Nathan left PyeongChang with one of the most memorable performances of the Winter Games in the men's event and finished in 5th place. In addition, he earned an Olympic bronze medal as part of Team USA in the Olympic Team Event. One month later, Nathan went on the win the 2018 World Championships in Milan for his first World title.
After repeating as champion at the 2018 Grand Prix Final, Nathan won his third consecutive title at the 2019 U.S. Figure Skating Championships in Detroit. He scored 113.42 in his short program and 228.80 in the free skate for a total of 342.22. All three scores were personal bests for Nathan, and as well as all-time U.S. championships records. He beat his closest competitor by an astounding 58.21 points.
At the 2019 World Championships in Saitama, Japan, Nathan became the first American man to successfully defend his World title since Scott Hamilton in 1983/1984. Nathan broke the ISU world records in both the free skate (216.02) and total points (323.42), beating out two-time Olympic champion Yuzuru Hanyu of Japan.
Although he is best known for his technical prowess, Nathan is more than just a jumping machine. He has worked with some of the most noted choreographers in the sport to improve his artistic side of the skating. He enlisted Canadian world champion ice dancer Shae-Lynn Bourne to craft his short programs for the past two seasons, and Marie-France Dubreuil to create his 2018/2019 free skate. Nathan also has a strong background in ballet, having trained at the renowned Ballet West Academy during his youth.
Nathan is most at home in an ice rink, and it makes sense given his family's passion for anything on ice. Both of his brothers, Tony and Colin, played hockey. Both of Nathan's sisters, Alice and Janice, took up figure skating. For years, Nathan competed in both figure skating and hockey, until figure skating ultimately won the battle of the blades.
Off the ice, Nathan enjoys playing guitar, biking and long boarding along the California beaches. In the fall of 2018, Nathan started his freshman year at Yale University in New Haven, CT. And typical of Nathan to challenge himself, he is taking a full course load while competing and training as he is aiming to return to the Olympics in 2022. At 20 years old, Nathan has already made a name for himself in the sport. But his work has just begun, and Nathan hopes to continue setting new records and pushing figure skating to new heights.
2019 – World Championships – 1st
2019 – U.S. Championships – 1st
2018 – Grand Prix Final – 1st
2018 – Skate America – 1st
2018 – Olympics – Bronze Medal (Team)
2018 – Olympics – 5th
2017 – Rostelecom Cup – 1st
2017 – U.S. International Classic – 1st
2017 – World Championships – 6th
2017 – Four Continents Championships – 1st
2016 – Grand Prix Final – 2nd
2016 – U.S. Championships – 3rd
2015 – ISU Junior Grand Prix Final – 1st
2014 – World Junior Championships – 3rd
2014 – U.S. Championships (junior) – 1st
2011 – U.S. Championships (novice) – 1st
Follow Nathan:
Twitter: @nathanwchen
Instagram: nathanwchen
Official Facebook: www.facebook.com/NathanChenFigureSkater
Website: http://figureskatersonline.com/nathanchen/


SDM Summer Festival | Square Dance Minnesota, Inc.
July 29, 2018 – SDM Summer Festival Square Dance, St Cloud, Callers Tom Allen, Andy Flint, Larry Fruetel, Denise Heinz, and Charley Huhtala, Cuers Sarah Klaphake, Ken LaBau, and Donna Stone. Square Dance Minnesota celebrated its fourth anniversary as a 501(c)(3) nonprofit organization at the festival.
Lola received her Octogenarian Live Lively award.
Mavis received her Septuagenarian Live Lively award.
Willard was the Third Most-Active January-June dancer.
Don and Mavis were the second Most-Active January-June dancers.
Barry was the Most-Active January-June dancer.
Doug & Gael received their fifth Traveler award.
Sally and Ken received the 501(c)(3) letter certification for Gospel Plus.
Deb received a Certificate of Appreciation for four years service as a board member (treasurer).


Positive Behavior Interventions and Supports, or PBIS, is a system with long-standing results. PBIS aims to teach core skills as they pertain to behavioral expectations, similar to how schools teach core curriculum expectations. Whaley School, a separate day school for students with acute behavior needs, has been using the PBIS model for five years in the Anchorage School District. We believe that much of our PBIS success is due to the work we have done in four key groups: students, staff, families, and community.
When students exhibit these behaviors, they receive P.A.C.K. cash. On Friday, students visit the school store stocked with items supported strictly by donation—such as clothing, games, toys, food, and more—and can "purchase" these items with their P.A.C.K. cash.
Prior to their time at Whaley, students had seldom been recognized for positive behaviors and instead had been punished for negative behaviors. While it seems simple, recognizing positive behaviors with P.A.C.K. cash has been motivating for students. It helps them be more aware of their classroom and school behavior and has minimized negative behaviors.
PBIS is not only for students in the building, it's also for staff. We recognize staff with a "Staff of the Month" award. Students and staff nominate staff members who have made a difference that month through a survey, and the school votes on the nominations. Those who are recognized win various prizes. This program has not only helped to boost staff morale, but it has also been a great way to show staff members what teaching behaviors benefit students the most.
Connect parents to the school community and show them how they can get involved.
Educate parents about our curriculum and the reasoning behind the different course options and educational tracks.
Explore ways that students can get involved in the school and the community to add to their academic education.
Teach parents skills and strategies to use at home to support their child.
We've found that Parent University has been instrumental in our work with our students. It has increased parental involvement, reduced parental frustrations with the school, and improved student learning because of the extra support they are receiving at home. Truly, our school and families work as a unit for the betterment of all of our students.
Without the support of our community members, PBIS would fail. Getting the word out to the community regarding what we do, how we do it, and the purpose of PBIS is the best way to show the community that we can work together as one to create success in school and the community. Whaley invites our community members to our annual Gala and Silent Auction. This event raises awareness of what we do and raises money for items for our school store. It allows the community to get an inside look into our school community. We also regularly invite community members to teach lessons or share what they do in the community to give a better perspective to our students.
PBIS is a system that can be implemented at any school regardless of grade level. Creating an environment with specific expectations throughout the building helps students to recognize normalcy in the real world. PBIS should be a means to teach students what daily expectations are in and out of school, thus the success of their actions is rewarded—just like on a job.
What are your experiences with PBIS? How do you work with students, staff, families, and the community to implement and support PBIS in your school?
Robyn Harris has been an administrator for the Anchorage School District for 10 years and is the principal of Whaley School, a separate day school for students with acute behavior needs. She is the 2018 Alaska Principal of the Year.
I'm so proud of you! You are a talented writer and an inspirational and passionate leader. I'm proud to say that I work with you. Thank you for challenging me to grow as a school leader.


text:
Fascial Stretch Therapy
What is FST?
Price for FST
What is Pilates
Our Pilates Classes
Price List for Pilates
REIKE & CHI
For Pilates
For FST
For REIKE & CHI Sessions
Want to know more what we do?
Your Pilates & Stretch Studio
We are located in the heart of downtown Nacogdoches. Come visit us at 110 S. Pecan Street Nacogdoches TX.
Elena Ramirez
Krystin Walker
Certified Pilates Teacher, Fascial Stretch Therapist, Lagree Instructor
Elena Ramirez is the founder and owner of Stretch ER located in downtown Nacogdoches, Texas. Elena opened Stretch ER in 2016 on a drive that felt like it was destined with the goal to treat the whole body and enable people to achieve their desired lifestyle through Fa
Elena Ramirez is the founder and owner of Stretch ER located in downtown Nacogdoches, Texas. Elena opened Stretch ER in 2016 on a drive that felt like it was destined with the goal to treat the whole body and enable people to achieve their desired lifestyle through Fascial Stretch Therapy and Pilates. In 2004 Elena started her service of 8 years in the United States Air Force as an Aerospace Medical Technician specializing in Intensive Care. Gladly serving tours in Germany, Iraq, and Afghanistan earning the Air Force and Army Commendation Medals along with many others. Elena became a Physical Training Leader early on in her military career and infused Pilates to the workouts. The United States Air Force brought Elena to Las Vegas, NV, where she attended The Pilates Studio and received her comprehensive Pilates certification and Barre A+ certification in 2011, and her Pilates Method Alliance Certification in 2016. In the midst of her Pilates teaching, Elena attended the University of Las Vegas, graduating with her Bachelors in Kinesiological Sciences in 2015. During the same time she underwent training at the Stretch to Win Institute in Tempe, Arizona. Obtaining her Fascial Stretch Therapist Level 1, Level 2, Level 3-Medical Specialist, and Life Stretch Teacher certifications from the Stretch to Win Institute in Tempe, Arizona. In 2022, Elena gained her Lagree Method certification and Oov certification. Pilates ER was brewing and became its true self in 2021 with the intention to bringing the flyest Pilates apparel to the people. The worlds in an oyster and Elena is polishing the prettiest of pearls.
LVN, Fascial Stretch Therapist and Pilates Teacher
Krystin Walker was born and raised in Lufkin TX. She danced her way through Pineywoods Academy High School. Krystin's very motivated self graduated from Angelina College with an Art degree the same time she graduated from High school in 2016. She obtained her nursing degree from Tyler Co
Krystin Walker was born and raised in Lufkin TX. She danced her way through Pineywoods Academy High School. Krystin's very motivated self graduated from Angelina College with an Art degree the same time she graduated from High school in 2016. She obtained her nursing degree from Tyler County school of nursing. Krystin then moved to Austin, TX where she found a love for holistic health, plant based living, and Pilates. Krystin moved back to her roots and wanted to further her education in Pilates and that's when she learned of Stretch ER. Krystin is a wonderful comprehensive Pilates Teacher and Barre trained. Attending the Stretch to Win Institute in 2022 gaining her Fascial Stretch Therapy certification and now is healing in the deep East Texas area.
Feel free to contact us with any questions or inquiries, or to learn more about our class schedules.
Stretch ER
110 South Pecan Street, Nacogdoches, Texas 75961, United States
info@stretch-er.com 936-569-1044
Reviews on MindBody app
Copyright © 2022 Stretch ER - All Rights Reserved.