text:
America's Dangerous Anti-Iran Posturing
In recent weeks, US President Donald Trump and his advisers have joined Saudi Arabia in accusing Iran of being the epicenter of Middle East terrorism. The US Congress, meanwhile, is readying yet another round of sanctions against Iran. But the caricature of Iran as "the tip of the spear" of global terrorism, in Saudi King Salman's words, is not only wrongheaded, but also extremely dangerous, because it could lead to yet another Middle East war.
In fact, that seems to be the goal of some US hotheads, despite the obvious fact that Iran is on the same side as the United States in opposing the Islamic State (ISIS). And then there's the fact that Iran, unlike most of its regional adversaries, is a functioning democracy. Ironically, the escalation of US and Saudi rhetoric came just two days after Iran's May 19 election, in which moderates led by incumbent President Hassan Rouhani defeated their hardline opponents at the ballot box.
Perhaps for Trump, the pro-Saudi, anti-Iran embrace is just another business proposition. He beamed at Saudi Arabia's decision to buy $110 billion of new US weapons, describing the deal as "jobs, jobs, jobs," as if the only gainful employment for American workers requires them to stoke war. And who knows what private deals for Trump and his family might also be lurking in his warm embrace of Saudi belligerence.
The Trump administration's bombast toward Iran is, in a sense, par for the course. US foreign policy is littered with absurd, tragic, and hugely destructive foreign wars that served no real purpose except the pursuit of some misguided strand of official propaganda. How else, in the end, to explain America's useless and hugely costly entanglements in Vietnam, Afghanistan, Iraq, Syria, Libya, Yemen, and many other conflicts?
America's anti-Iran animus goes back to the country's 1979 Islamic Revolution. For the US public, the 444-day ordeal of the US embassy staff held hostage by radical Iranian students constituted a psychological shock that has still not abated. The hostage drama dominated the US media from start to finish, resulting in a kind of public post-traumatic stress disorder similar to the social trauma of the 9/11 attacks a generation later.
For most Americans, then and now, the hostage crisis – and indeed the Iranian Revolution itself – was a bolt out of the blue. Few Americans realize that the Iranian Revolution came a quarter-century after the CIA and Britain's intelligence agency MI6 conspired in 1953 to overthrow the country's democratically elected government and install a police state under the Shah of Iran, to preserve Anglo-American control over Iran's oil, which was threatened by nationalization. Nor do most Americans realize that the hostage crisis was precipitated by the ill-considered decision to admit the deposed Shah into the US for medical treatment, which many Iranians viewed as a threat to the revolution.
During the Reagan Administration, the US supported Iraq in its war of aggression against Iran, including Iraq's use of chemical weapons. When the fighting finally ended in 1988, the US followed up with financial and trade sanctions on Iran that remain in place to this day. Since 1953, the US has opposed Iran's self-rule and economic development through covert action, support for authoritarian rule during 1953-79, military backing for its enemies, and decades-long sanctions.
Another reason for America's anti-Iran animus is Iran's support for Hezbollah and Hamas, two militant antagonists of Israel. Here, too, it is important to understand the historical context.
In 1982, Israel invaded Lebanon in an attempt to crush militant Palestinians operating there. In the wake of that war, and against the backdrop of anti-Muslim massacres enabled by Israel's occupation forces, Iran supported the formation of the Shia-led Hezbollah to resist Israel's occupation of southern Lebanon. By the time Israel withdrew from Lebanon in 2000, nearly 20 years after its original invasion, Hezbollah had become a formidable military, political, and social force in Lebanon, and a continuing thorn in Israel's side.
Iran also supports Hamas, a hardline Sunni group that rejects Israel's right to exist. Following decades of Israeli occupation of Palestinian lands captured in the 1967 war, and with peace negotiations stalemated, Hamas defeated Fatah (the Palestine Liberation Organization's political party) at the ballot box in the 2006 election for the Palestinian parliament. Rather than entering into a dialogue with Hamas, the US and Israel decided to try to crush it, including through a brutal war in Gaza in 2014, resulting in a massive Palestinian death toll, untold suffering, and billions of dollars in damage to homes and infrastructure in Gaza – but, predictably, leading to no political progress whatsoever.
Israel also views Iran's nuclear program as an existential threat. Hardline Israelis repeatedly sought to convince the US to attack Iran's nuclear facilities, or at least allow Israel to do so. Fortunately, President Barack Obama resisted, and instead negotiated a treaty between Iran and the five permanent members of the United Nations Security Council (plus Germany) that blocks Iran's path to nuclear weapons for a decade or more, creating space for further confidence-building measures on both sides. Yet Trump and the Saudis seem intent on destroying the possibility of normalizing relations created by this important and promising agreement.
External powers are extremely foolish to allow themselves to be manipulated into taking sides in bitter national or sectarian conflicts that can be resolved only by compromise. The Israel-Palestine conflict, the competition between Saudi Arabia and Iran, and the Sunni-Shia relationship all require mutual accommodation. Yet each side in these conflicts harbors the tragic illusion of achieving an ultimate victory without the need to compromise, if only the US (or some other major power) will fight the war on its behalf.
During the past century, Britain, France, the US, and Russia have all misplayed the Middle East power game. All have squandered lives, money, and prestige. (Indeed, the Soviet Union was gravely, perhaps fatally, weakened by its war in Afghanistan.) More than ever, we need an era of diplomacy that emphasizes compromise, not another round of demonization and an arms race that could all too easily spiral into disaster.


text:
The SWAP (Sewing With a Plan) has begun over on Stitcher's Guild, and I'm in. The emphasis for this year's swap is to make garments that are well-fitted and will become TNT (Tried and True) patterns. 2 garments can be previously sewn, and here are the basic rules:
Choose any seven garments from this list:
Button Down Shirt w/Collar
Blouse or shirt (collar is optional)
Shorts or Capri Pants
Jacket (jean jacket, windbreaker, hoodie, etc.)
Coat (suit or sport coat)
Overcoat or Raincoat
Bathing Suit & Coverup
From those seven, choose four to make twice for a total of 11 garments that will work together. Those four may either be repeated garments from the same pattern, or one each from two different patterns.
I think I've only actually completed one swap, although I have attempted a few. I'm hoping to "make it work" this year. I did not do 2 of the garments ahead of time, so that means I need to really get busy. I did make a "practice pair" of the pants and the Licorice dress. I have also made the coat before, but it is much too big now. I think it was a little too big when I made it the first time! Wow, I just looked back through the blog to find the picture of the coat and realized that it's been 5 years since I made that coat. I guess it is time to replace it. The new one will be a plain taupe colored wool. However, I LOVE the fabric of my gray coat and wish there were some way to salvage it. I guess I could take the whole thing apart and try to recut it. That would probably all work fine except for the buttonholes will make it tricky to recut the coat. And, I don't know that I'd ever be able to match up the pattern again either.
Well, for this year, this is what I'm planning..
The Burda jacket I also made years ago. I'm thinking about taking the Classic French Jacket class at Pattern Review. The class is $53.00 for memebers. One of my early Christmas presents was the Threads archive DVD set, so I may just follow the instructions in the past issues of threads on how to make a Chanel jacket. I haven't decided yet, but need to since the class starts on Jan 5th.

subset: commoncrawl


text:
"I think one thing that [the cameras] haven't captured is in the morning all the alarms going off in the boys' room. We're pretty hard sleepers."
-Joseph Duggar
In this TLCme video clip with interviewer Danni Starr, Joseph Duggar and Josiah Duggar share what it's like to have hundreds of hours of professional home movies to look back on and how filming for their reality show has changed their family.


text:
FREDERICTON, July 20, 2015 /CNW/ - Plaza Retail REIT ("Plaza") (TSX: PLZ.UN) today announced its July 2015 monthly distribution in the amount of $0.020833 per unit ($0.25 annualized). The July distribution will be payable on August 17, 2015 to unitholders of record as at July 31, 2015.
Plaza is an open-ended real estate investment trust and is a leading retail property owner and developer, particularly in Eastern Canada. Plaza's current portfolio includes interests in 305 properties totaling approximately 6.7 million square feet across Canada and additional lands held for development. Plaza's properties include a mix of strip plazas, stand-alone small box retail outlets and enclosed shopping centres, anchored by approximately 90% national tenants.
For more information on Plaza Retail REIT, visit our website at www.plaza.ca
SOURCE Plaza Retail REIT
or contact: Michael Zakuta, President and Chief Executive Officer, at (514) 457-0997; or Floriana Cipollone, Chief Financial Officer, at (416) 848-4583


text:
Ipsilon Infrastructure SOP
Contact Information
- Owner
Fedora Infrastructure Team
- Contact
- Primary upstream contact
Patrick Uiterwijk - FAS: puiterwijk
- Backup upstream contact
Simo Sorce - FAS: simo (irc: simo) Howard Johnson - FAS: merlinthp (irc: MerlinTHP) Rob Crittenden - FAS: rcritten (irc: rcrit)
- Servers
- Purpose
Ipsilon is our central authentication service that is used to authenticate users agains FAS. It is seperate from FAS.
Ipsilon is our central authentication agent that is used to authenticate users agains FAS. It is seperate from FAS. The only service that is not using this currently is the wiki. It is a web service that is presented via httpd and is load balanced by our standard haproxy setup.
Known issues
No known issues at this time. There is not currently a logout option for ipsilon, but it is not considered an issue. If group memberships are updated in ipsilon the user will need to wait a few minutes for them to replicate to the all the systems.
To restart the application you simply need to ssh to the servers for the
problematic region and issue an service httpd restart
. This should
rarely be required.
Configuration is handled by the ipsilon.yaml playbook in Ansible. This can also be used to reconfigure application, if that becomes necessary.
Common actions
This section describes some common configuration actions.
OpenID Connect Scope Registration
As documented on https://fedoraproject.org/wiki/Infrastructure/Authentication, application developers can request their own scopes. When a request for this comes in, look in ansible/roles/ipsilon/files/oidc_scopes/ and copy an example module. Copy this to a new file, so we have a file per scope set. Fill in the information:
name is an Ipsilon-internal name. This should not include any spaces
display_name is the name that is displayed to the category of scopes to the user
scopes is a dictionary with the full scope identifier (with namespace) as keys. The values are dicts with the following keys:
display_name: The complete display name for this scope. This is what the user gets shown to accept/reject
claims: A list of additional "claims" (pieces of user information) an application will get when the user consents to this scope. For most scopes, this will be the empty list.
In ansible/roles/ipsilon/tasks/main.yml, add the name of the new file (without .py) to the with_items of "Copy OpenID Connect scope registrations"). To enable, open ansible/roles/ipsilon/templates/configuration.conf, and look for the lines starting with "openidc enabled extensions". Add the name of the plugin (in the "name" field of the file) to the environment this scopeset has been requested for. Run the ansible ipsilon.yml playbook.
Generate an OpenID Connect token
There is a handy script in the Ansible project under
that can help you generate an OIDC token.
It has a self-explanatory --help
argument, and it will print out some
SQL that you can run against Ipsilon's database, as well as the token
that you seek.
The SERVICE_NAME
(the required positional argument) is the name of the
application that wants to use the token to perform actions against
another service.
To generate the scopes, you can visit our
authentication docs and
find the service you want the token to be used for. Each service has a
base namespace (a URL) and one or more scopes for that namespace. To
form a scope for this script, you concatenate the namespace of the
service with the scope you want to grant the service. You can provide
the script the -s
flag multiple times if you want to grant more than one
scope to the same token.
As an example, to give Bodhi access to create waivers in WaiverDB, you
can see that the base namespace is
and that there is a
scope. You can run this to generate Ipsilon SQL and a
token with that scope:
[bowlofeggs@batcave01 ansible][PROD]$ ./scripts/generate-oidc-token bodhi -e 365 -s https://waiverdb.fedoraproject.org/oidc/create-waiver Run this SQL against Ipsilon's database: --------START CUTTING HERE-------- BEGIN; insert into token values ('2a5f2dff-4e93-4a8d-8482-e62f40dce046','username','bodhi@service'); insert into token values ('2a5f2dff-4e93-4a8d-8482-e62f40dce046','security_check','-ptBqVLId-kUJquqkVyhvR0DbDULIiKp1eqbXqG_dfVK9qACU6WwRBN3-7TRfoOn'); insert into token values ('2a5f2dff-4e93-4a8d-8482-e62f40dce046','client_id','bodhi'); insert into token values ('2a5f2dff-4e93-4a8d-8482-e62f40dce046','expires_at','1557259744'); insert into token values ('2a5f2dff-4e93-4a8d-8482-e62f40dce046','type','Bearer'); insert into token values ('2a5f2dff-4e93-4a8d-8482-e62f40dce046','issued_at','1525723744'); insert into token values ('2a5f2dff-4e93-4a8d-8482-e62f40dce046','scope','["openid", "https://someapp.fedoraproject.org/"]'); COMMIT; -------- END CUTTING HERE -------- Token: 2a5f2dff-4e93-4a8d-8482-e62f40dce046_-ptBqVLId-kUJquqkVyhvR0DbDULIiKp1eqbXqG_dfVK9qACU6WwRBN3-7TRfoOn
Once you have the SQL, you can run it against Ipsilon's database, and you can provide the token to the application through some secure means (such as putting into Ansible's secrets and telling the requestor the Ansible variable they can use to access it.)
Create OpenID Connect secrets for apps
Application wanting to use OpenID Connect need to register against our OpenID Connect server (Ipsilon). Since we do not allow self-registration (except on iddev.fedorainfracloud.org) for obvious reasons, the secrets need to be created and configured per application and environment (production vs staging).
To do so: - Go to the private ansible repository. - Edit the file:
- At the bottom of this file, add
the information concerning the application you are adding. This will
look something like:
fedocal client_name="fedocal" fedocal client_secret="<long random string>" fedocal redirect_uris=["https://calendar.stg.fedoraproject.org/oidc_callback"] fedocal client_uri="https://calendar.stg.fedoraproject.org/" fedocal ipsilon_internal={"type":"static","client_id":"fedocal","trusted":true} fedocal contacts=["firstname.lastname@example.com"] fedocal client_id=null fedocal policy_uri="https://fedoraproject.org/wiki/Legal:PrivacyPolicy" fedocal grant_types="authorization_code" fedocal response_types="code" fedocal application_type="web" fedocal subject_type="pairwise" fedocal logo_uri=null fedocal tos_uri=null fedocal jwks_uri=null fedocal jwks=null fedocal sector_identifier_uri=null fedocal request_uris=[] fedocal require_auth_time=null fedocal token_endpoint_auth_method="client_secret_post" fedocal id_token_signed_response_alg="RS256" fedocal request_object_signing_alg="none" fedocal initiate_login_uri=null fedocal default_max_age=null fedocal default_acr_values=null fedocal client_secret_expires_at=0
In most of situation, only the first 5 lines (up to ipsilon_internal
will change. If the application is not using flask-oidc or is not
maintained by the Fedora Infrastructure the first 11 lines (up to
) may change. The remaining lines require a deeper
understanding of OpenID Connect and Ipsilon.
In our OpenID connect server, |
After adjusting this file, you will need to make the client_secret
available to the application via ansible, for this simply add it to
as we do for the other private variables and provide the
variable name to the person who requested it.
Finally, commit and push the changes to both files and run the
Want to help? Learn how to contribute to Fedora Docs ›


text:
LEHI, Utah – The Legacy Center in Lehi, Utah, has been a staple of suburban Salt Lake City for decades. Countless numbers of children have learned self-confidence on the courts and balance on the beams. When COVID-19 hit, it meant game over.
"I just stayed home and didn't do that much," said 10-year-old Michael Jacob.
For the kids, the closure of the recreation center was a crushing defeat.
"I felt horrible," said 11-year-old Copper Hill. "I was like thinking, 'this sucks that I don't get to play baseball this year.'"
Many parents felt the same way.
"Emotionally, you know, it took a big toll on them and on us when they weren't able to get out and be involved," said parent Jeremy Hill.
However, as things began to normalize, the city saw an opportunity to try and safely reopen.
Brittany Crumback oversees all the youth sports for the city.
"I think a lot of local support from our city council and our city administration helped a lot because they really wanted us to have programs to give the kids something to do," Crumback said.
So, the city came up with a playbook for the new normal, including temperature checks at the door, face masks for anyone not actively playing a sport, a limit on spectators and contact tracing.
"For the most part, it's kind of business as usual, just a little safer," Crumback said.
Crumback admits all the extra planning to make this season happen hasn't been a slam dunk, but it's been worth it.
"To see a junior in high school be so excited to come and play basketball with our rec center is just amazing," Crumback said with a smile. "That is why we do it and yeah this is working."
Crumback said, so far, no outbreaks have been linked to the facility.
Sure, everyone in the building would still like to karate chop the virus, but at least for now, the kids have a little piece of their old lives back.
"One of my ways to express my feelings is through sports and stuff like that and I would just hate to not be able to do that," Hill said.
And that's a win no matter what the numbers read on the scoreboard.
"Overall, it's been great. The kids are just so excited," Crumback said. "You come into this and I've never seen kids happier to play basketball."


text:
A few tips when using Le Tote:
- Add items for all occasions to your closet - work, date night, weekends, sporting events, etc.
- Fill out your style profile honestly and review the items you do receive. This will help your stylists to understand your personal style and recognize favorite trends or brands that you love to wear.
- Avoid receiving items that aren't a perfect fit by using the measuring tape that Le Tote sends you as part of your first tote. Pay attention to your bust, hips & waist sizes.
- Update your closet consistently. Add pieces to your closet that match the seasons so you always end up with something great to wear. I currently have 50+ pieces in my closet (about half are for summer & half are for fall!)
When your tote arrives, get ready to show off your brand new pieces. You wear everything in your tote & once you get sick of it, you mail it back. (Le Tote takes care of the shipping & dry cleaning!) A new tote full of new items will arrive right on your doorstep. If you really love an item, you can purchase it at a reduced price. So what are you waiting for? Go try out Le Tote now!
Dress, Jacket, Bag, Earrings: all c/o Le Tote | Shoes: INC (old, similar)
And for ALL of you, interested in trying out Le Tote - they are offering Michelle's Paige readers $25 off their next tote!


text:
Rely on licensed HVAC Contractors in Jumeirah Park, DXB for reliable heating and cooling services.
HVAC Pro has the best HVAC contractors in Jumeirah Park, DXB who are always available to offer their top services. HVAC is distinct from normal ACs because it can perform a lot more than your typical AC unit. HVAC is a term used to describe Heating, ventilation, as well as air conditioning. This means the utilization of different HVAC Technologies to manage the humidity, temperature, and cleanliness of the air within the confines of a room. The goal of HVAC is to offer comfort in the thermal environment as well as an adequate quality of indoor air. If you're thinking of changing your Air Conditioner as you're fed up with paying for repairs, or you'd like to benefit from new models that have more capabilities and higher efficiency, getting an experienced HVAC Pro HVAC Contractor across Jumeirah Park, DXB will help you get the most out of this major investment. Our technicians are involved in HVAC installation, maintenance, and repairs. For more information about the HVAC services, please contact us. Our team will be happy to accommodate your request.
If you ever need to know how to locate the top HVAC Contractors Near you in Jumeirah Park, DXB? The most straightforward answer is HVAC Pro. HVAC contractors from HVAC Pro provide AC Installation Specialists that provide repairs, maintenance, and maintenance. We provide HVAC services that are reliable and affordable. Hire our HVAV contractors without having to worry about a loss of money.
HVAC Pro is the most reputable company in a leading HVAC service industry that has Licensed HVAC Contractors within Jumeirah Park, DXB for Air Conditioning Installation Service. Your HVAC units are definitely an investment that is costly. For the greatest benefit, it is essential to be able to trust a professional to install or maintain it. Do not trust any amateur with this task, since it may not only cause damage to your HVAC System, but it could even damage your home which could result in you spending lots of dollars. In order to ensure that the warranty is maintained and backed by our HVAC Experts, HVAC Pro is certified to complete the task for you. For you to protect your costly investment and enjoy it, count upon our Emergency AC Service in Jumeirah Park, DXB. To request a reasonable estimate, contact our staff at the front desk at any time.
HVAC Pro provides its service to commercial as well as residential HVAC units. When you need Top-Quality Commercial HVAC Contractors in Jumeirah Park, DXB you can count on our skilled and knowledgeable staff. Our team is equipped with the expertise to resolve any HVAC problem. Contact our team to schedule an appointment today.
HVAC Pro can be the locally-based company to trust to install, repair, and repair Your Local HVAC Repair. Find the Top Local HVAC Contractors in Jumeirah Park, DXB exclusively at HVAC Pro. We want our customers to be satisfied. This is the top priority of our HVAC contractors. All over the Jumeirah Park, DXB area, there's only one option to use HVAC, HVAC Pro. If your home or business requires New Air Conditioning And Heating Installations or maintenance on the ventilation systems of your home we will be able to complete the job quickly and efficiently. HVAC Pro's HVAC experts are the best of the best in giving you a customized solution to your issues and offering the lowest cost solution. Don't wait around and make the smart decision to hire HVAC Pro.
HVAC Pro offers the most trustworthy Industrial HVAC Contractors in Jumeirah Park, DXB. We've chosen the best experts with the right knowledge and skills to ensure that your Industrial HVAC System operates smoothly. Our HVAC Contractors' services are available all hours of the day Don't be hesitant to call us no matter the time of day to resolve any HVAC emergency.
For the top residential HVAC Contractors in Jumeirah Park, DXB, HVAC Pro is the ideal place. If you require a Licensed Heating Contractor for residential HVAC, we've provided you with all related services. When you call us, we'll arrange an appointment to evaluate the situation. If we are faced with an emergency, we'll call a professional to visit your residence as soon as possible.
HVAC Pro has a team of certified Top Commercial HVAC Contractors in Jumeirah Park, DXB. Our professionals are able to handle any kind of size, shape, or size of HVAC to ensure you get the highest output. We'll give you an estimate for each of the necessary HVAC Services. Our technicians will get to work as soon as they get your approval for the HVAC system for your commercial building.
"Great, professional HVAC technicians from HVAC Pro in Jumeirah Park, DXB. They are very knowledgeable and skilled in every aspect of what I needed. I would surely recommend them to anyone. They are top notch."
"HVAC expert from HVAC Pro in Jumeirah Park, DXB worked professionally to get new ac/heating units. Their maintenance had been wonderful. I highly recommend these professionals to anyone needing ac/heating issues."
"Many thanks to HVAC Pro in Jumeirah Park, DXB for solving my HVAC problems. Their technicians were very courteous, professional, and pleasant. They quickly fixed the issue and maintained the HVAC system."


text:
Share templates
A simple way to share code templates is to export them them into files and then share these files with other developers, who in their turn, will be able to import and use the templates.
Another way of sharing templates with your team members is using the mechanism of settings layers that ReSharper uses to store code templates. To make templates available to other developers who work on the same shared solution, you can either create new code templates in a team-shared settings layer or copy existing templates to a team-shared settings layer.
Create a shared code template
In the main menu, choose
.In the Templates Explorer window that appears, click one of the tabs to choose the type of the template: Live Templates, Surround Templates, or File Templates.
In the Layer selector, choose Solution [solution name] team-shared or another custom shared layer.
Follow the creating a template procedure.
Share existing code templates
Click Manage Layers on the Templates Explorer window toolbar or choose in the main menu.
In the Settings Layers dialog that appears, select a layer that contains templates to be shared.
Right-click the layer, select Copy Settings To and choose Solution [solution name] team-shared or another shared settings layer in the context menu.
In the Copy To dialog that appears, select the LiveTemplates checkbox under PatternsAndTemplates.
Click OK to complete the process.
In ReSharper's Storage of templates, it is possible that some settings layers may contain modifications to templates defined in other layers. If you want to make sure that the layer you are going to share contains correct template definitions, choose this layer in the Layer selector, click Filter Templates and disable Show predefined templates, then find your templates and double-click them to study them. If you cannot find some user-defined template in a specific layer, but still you can see it when the Smart layer is selected, then this template is actually defined in another layer. If the template is visible in a specific layer, but some of its fields differ when the Smart layer is selected, then these fields are overridden in upper layers and these modifications will not be shared.


text:
Harry Potter fans, this one's for you! (though I suspect a quick read of the yummy ingredients will entice even the staunchest muggle) Amy of Amy Bites created the recipe for butterbeer cupcakes after visiting the Wizarding World of Harry Potter at Universal's Islands of Adventure park.
Even if you have no idea what butterbeer is or have never tasted it, you will love these. Essentially, the flavor profile is that of a buttery cream soda cake, filled with butterscotch ganache, topped with a butterscotch buttercream and drizzled with more butterscotch ganache. It sounds kind of intense, but trust me on this. They're amazing.
Yum, indeed! [via Sweet Tooth and Bake at 350]
Join Make: Community Today


text:
During President Obama's final push for "universal health care" legislation, his biggest obstacle was not Republicans but rather anti-abortion Democrats let by Congressman Bart Stupak (D-Michigan).
Stupak eventually reached a last-minute deal with the White House on federal funding of abortion services. But no one should be surprised that under government-controlled health insurance, medical coverage decisions will be based on political considerations. Rather, the recent wrangling over abortion will be a mere preview of special-interest battles to come as health care becomes a permanent political football.
Abortion has already been a political football in those sectors of health insurance under government control. In 1985, the Department of Defense denied abortion coverage for women with military health insurance unless the mother's life was in danger. In 1988, the DOD issued additional rules prohibiting women from obtaining abortions with their own private money at military facilities overseas. President Clinton reversed this ban in 1993, but anti-abortion lawmakers reinstated it in 1995 through the defense appropriations bill.
Women covered by the Federal Employees Health Benefits Program (FEHBP) have been similarly affected. Over the past thirty years, their abortion coverage has also swung from permitted to highly restricted depending on which political party was in power.
Nor will the problem of politicized health benefits be confined to abortion. ObamaCare gives the U.S. Preventative Services Task Force (USPSTF) the authority to determine which preventive health services must be covered by private insurance. The USPSTF is the same group that recently issued controversial guidelines recommending that screening mammography be restricted to women over age 50, despite the fact that medical organizations such as the American Cancer Society have long recommended routine mammography beginning at age 40, based on years of scientific research.
Due to public outrage, the Senate later amended its bill to override the USPSTF guidelines — in this particular case. As with abortions for military families, mammography coverage under government-controlled health insurance was determined primarily by politics and lobbying. Similar lobbying will occur as Americans start demanding coverage for other procedures not approved by the USPSTF, such as virtual colonography (a new method of detecting early colon cancer which President Obama himself recently underwent).
Such lobbying is already a constant feature under the Massachusetts system of mandatory insurance in place since 2006, which was the model for ObamaCare. Under any system of mandatory insurance, the government must necessarily determine what constitutes an "acceptable" policy. This creates a giant magnet for special interest groups seeking to include their favorite benefit in the mandatory package.
Massachusetts residents must therefore purchase numerous benefits they may neither need nor want, such as in vitro fertilization and chiropractor services. Since 2006, special interest groups have successfully lobbied to include 16 new benefits in the mandatory package (including lay midwives, orthotics, and drug abuse treatment) — and the state legislature is considering 70 more.
Although I am pro-choice on abortion, abortion opponents should not be forced to fund another woman's abortion. More broadly, individuals have the right to spend their own money for their benefit according to their values. ObamaCare would violate that right by forcing each person to spend his own money on terms set by lobbyists and bureaucrats, rather than based on his individual needs and values.
Instead of politically-controlled mandatory health insurance, we need free-market reforms that allow consumers to decide which benefits they wish to purchase. Such reforms include eliminating mandatory benefits, allowing insurers to compete across state lines, and allowing patients to use Health Savings Accounts for routine expenses, and low-cost "catastrophic-only" plans to cover rare expensive events.
Not only would these reforms reduce insurance costs by up to 50 percent, they would respect each individual's right to make insurance decisions for himself.
Government-controlled health insurance will mean politically-controlled medicine — not only with respect to abortion but for health services in general. ObamaCare will turn medicine into a game of permanent political football, where the politically favored perpetually pound ordinary Americans without special "pull." Until we replace ObamaCare with free-market reforms, Americans had better get used to being the permanent tackling dummies for special-interest groups.


text:
The following is a collection of tips I find to be useful when working with the Swift language. More content is available on my Twitter account!
- #57 Property Wrappers as Debugging Tools
- #56 Localization through
interpolation - #55 Implementing pseudo-inheritance between
- #54 Composing
through a Function Builder - #53 Using
as expressions - #52 Avoiding double negatives within
statements - #51 Defining a custom
without loosing the compiler-generated one - #50 Implementing a namespace through an empty
- #49 Using
to represent impossible code paths - #48 Providing a default value to a
- #47 Another lightweight dependency injection through default values for function parameters
- #46 Lightweight dependency injection through protocol-oriented programming
- #45 Getting rid of overabundant
[weak self]
- #44 Solving callback hell with function composition
- #43 Transform an asynchronous function into a synchronous one
- #42 Using KeyPaths instead of closures
- #41 Bringing some type-safety to a
- #40 Lightweight data-binding for an MVVM implementation
- #39 Using
to its fullest - #38 Writing an interruptible overload of
- #37 Optimizing the use of
- #36 Avoiding hardcoded reuse identifiers
- #35 Defining a union type
- #34 Asserting that classes have associated NIBs and vice-versa
- #33 Small footprint type-erasing with functions
- #32 Performing animations sequentially
- #31 Debouncing a function call
- #30 Providing useful operators for
booleans - #29 Removing duplicate values from a
- #28 Shorter syntax to deal with optional strings
- #27 Encapsulating background computation and UI update
- #26 Retrieving all the necessary data to build a debug view
- #25 Defining a function to map over dictionaries
- #24 A shorter syntax to remove
values - #23 Dealing with expirable values
- #22 Using parallelism to speed-up
- #21 Measuring execution time with minimum boilerplate
- #20 Running two pieces of code in parallel
- #19 Making good use of #file, #line and #function
- #18 Comparing Optionals through Conditional Conformance
- #17 Safely subscripting a Collection
- #16 Easier String slicing using ranges
- #15 Concise syntax for sorting using a KeyPath
- #14 Manufacturing cache-efficient versions of pure functions
- #13 Simplifying complex condition with pattern matching
- #12 Easily generating arrays of data
- #11 Using @autoclosure for cleaner call sites
- #10 Observing new and old value with RxSwift
- #09 Implicit initialization from literal values
- #08 Achieving systematic validation of data
- #07 Implementing the builder pattern with keypaths
- #06 Storing functions rather than values
- #05 Defining operators on function types
- #04 Typealiases for functions
- #03 Encapsulating state within a function
- #02 Generating all cases for an Enum
- #01 Using map on optional values
Property Wrappers as Debugging Tools
Property Wrappers allow developers to wrap properties with specific behaviors, that will be seamlessly triggered whenever the properties are accessed.
While their primary use case is to implement business logic within our apps, it's also possible to use Property Wrappers as debugging tools!
For example, we could build a wrapper called @History
, that would be added to a property while debugging and would keep track of all the values set to this property.
import Foundation
struct History<Value> {
private var value: Value
private(set) var history: [Value] = []
init(wrappedValue: Value) {
self.value = wrappedValue
var wrappedValue: Value {
get { value }
set {
value = newValue
var projectedValue: Self {
return self
// We can then decorate our business code
// with the `@History` wrapper
struct User {
@History var name: String = ""
var user = User()
// All the existing call sites will still
// compile, without the need for any change
user.name = "John"
user.name = "Jane"
// But now we can also access an history of
// all the previous values!
user.$name.history // ["", "John"]
Localization through Swift 5 gave us the possibility to define our own custom String
interpolation methods.
This feature can be used to power many use cases, but there is one that is guaranteed to make sense in most projects: localizing user-facing strings.
import Foundation
extension String.StringInterpolation {
mutating func appendInterpolation(localized key: String, _ args: CVarArg...) {
let localized = String(format: NSLocalizedString(key, comment: ""), arguments: args)
Let's assume that this is the content of our Localizable.strings:
"welcome.screen.greetings" = "Hello %@!";
let userName = "John"
print("\(localized: "welcome.screen.greetings", userName)") // Hello John!
Implementing pseudo-inheritance between If you've always wanted to use some kind of inheritance mechanism for your structs, Swift 5.1 is going to make you very happy!
Using the new KeyPath-based dynamic member lookup, you can implement some pseudo-inheritance, where a type inherits the API of another one
(However, be careful, I'm definitely not advocating inheritance as a go-to solution
import Foundation
protocol Inherits {
associatedtype SuperType
var `super`: SuperType { get }
extension Inherits {
subscript<T>(dynamicMember keyPath: KeyPath<SuperType, T>) -> T {
return self.`super`[keyPath: keyPath]
struct Person {
let name: String
struct User: Inherits {
let `super`: Person
let login: String
let password: String
let user = User(super: Person(name: "John Appleseed"), login: "Johnny", password: "1234")
user.name // "John Appleseed"
user.login // "Johnny"
through a Function Builder
Composing Swift 5.1 introduced Function Builders: a great tool for building custom DSL syntaxes, like SwiftUI. However, one doesn't need to be building a full-fledged DSL in order to leverage them.
For example, it's possible to write a simple Function Builder, whose job will be to compose together individual instances of NSAttributedString
through a nicer syntax than the standard API.
import UIKit
class NSAttributedStringBuilder {
static func buildBlock(_ components: NSAttributedString...) -> NSAttributedString {
let result = NSMutableAttributedString(string: "")
return components.reduce(into: result) { (result, current) in result.append(current) }
extension NSAttributedString {
class func composing(@NSAttributedStringBuilder _ parts: () -> NSAttributedString) -> NSAttributedString {
return parts()
let result = NSAttributedString.composing {
NSAttributedString(string: "Hello",
attributes: [.font: UIFont.systemFont(ofSize: 24),
.foregroundColor: UIColor.red])
NSAttributedString(string: " world!",
attributes: [.font: UIFont.systemFont(ofSize: 20),
.foregroundColor: UIColor.orange])
and if
as expressions
Using Contrary to other languages, like Kotlin, Swift does not allow switch
and if
to be used as expressions. Meaning that the following code is not valid Swift:
let constant = if condition {
} else {
A common solution to this problem is to wrap the if
or switch
statement within a closure, that will then be immediately called. While this approach does manage to achieve the desired goal, it makes for a rather poor syntax.
To avoid the ugly trailing ()
and improve on the readability, you can define a resultOf
function, that will serve the exact same purpose, in a more elegant way.
import Foundation
func resultOf<T>(_ code: () -> T) -> T {
return code()
let randomInt = Int.random(in: 0...3)
let spelledOut: String = resultOf {
switch randomInt {
case 0:
return "Zero"
case 1:
return "One"
case 2:
return "Two"
case 3:
return "Three"
return "Out of range"
Avoiding double negatives within A guard
statement is a very convenient way for the developer to assert that a condition is met, in order for the execution of the program to keep going.
However, since the body of a guard
statement is meant to be executed when the condition evaluates to false
, the use of the negation (!
) operator within the condition of a guard
statement can make the code hard to read, as it becomes a double negative.
A nice trick to avoid such double negatives is to encapsulate the use of the !
operator within a new property or function, whose name does not include a negative.
import Foundation
extension Collection {
var hasElements: Bool {
return !isEmpty
let array = Bool.random() ? [1, 2, 3] : []
guard array.hasElements else { fatalError("array was empty") }
without loosing the compiler-generated one
Defining a custom It's common knowledge for Swift developers that, when you define a struct
, the compiler is going to automatically generate a memberwise init
for you. That is, unless you also define an init
of your own. Because then, the compiler won't generate any memberwise init
Yet, there are many instances where we might enjoy the opportunity to get both. As it turns out, this goal is quite easy to achieve: you just need to define your own init
in an extension
rather than inside the type definition itself.
import Foundation
struct Point {
let x: Int
let y: Int
extension Point {
init() {
x = 0
y = 0
let usingDefaultInit = Point(x: 4, y: 3)
let usingCustomInit = Point()
Implementing a namespace through an empty Swift does not really have an out-of-the-box support of namespaces. One could argue that a Swift module can be seen as a namespace, but creating a dedicated Framework for this sole purpose can legitimately be regarded as overkill.
Some developers have taken the habit to use a struct
which only contains static
fields to implement a namespace. While this does the job, it requires us to remember to implement an empty private
, because it wouldn't make sense for such a struct
to be instantiated.
It's actually possible to take this approach one step further, by replacing the struct
with an enum
. While it might seem weird to have an enum
with no case
, it's actually a very idiomatic way to declare a type that cannot be instantiated.
import Foundation
enum NumberFormatterProvider {
static var currencyFormatter: NumberFormatter {
let formatter = NumberFormatter()
formatter.numberStyle = .currency
formatter.roundingIncrement = 0.01
return formatter
static var decimalFormatter: NumberFormatter {
let formatter = NumberFormatter()
formatter.numberStyle = .decimal
formatter.decimalSeparator = ","
return formatter
NumberFormatterProvider() // ❌ impossible to instantiate by mistake
NumberFormatterProvider.currencyFormatter.string(from: 2.456) // $2.46
NumberFormatterProvider.decimalFormatter.string(from: 2.456) // 2,456
to represent impossible code paths
Using Never
is quite a peculiar type in the Swift Standard Library: it is defined as an empty enum enum Never { }
While this might seem odd at first glance, it actually yields a very interesting property: it makes it a type that cannot be constructed (i.e. it possesses no instances).
This way, Never
can be used as a generic parameter to let the compiler know that a particular feature will not be used.
import Foundation
enum Result<Value, Error> {
case success(value: Value)
case failure(error: Error)
func willAlwaysSucceed(_ completion: @escaping ((Result<String, Never>) -> Void)) {
completion(.success(value: "Call was successful"))
willAlwaysSucceed( { result in
switch result {
case .success(let value):
// the compiler knows that the `failure` case cannot happen
// so it doesn't require us to handle it.
Providing a default value to a Swift's Codable
framework does a great job at seamlessly decoding entities from a JSON stream. However, when we integrate web-services, we are sometimes left to deal with JSONs that require behaviors that Codable
does not provide out-of-the-box.
For instance, we might have a string-based or integer-based enum
, and be required to set it to a default value when the data found in the JSON does not match any of its cases.
We might be tempted to implement this via an extensive switch
statement over all the possible cases, but there is a much shorter alternative through the initializer init?(rawValue:)
import Foundation
enum State: String, Decodable {
case active
case inactive
case undefined
init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
let decodedString = try container.decode(String.self)
self = State(rawValue: decodedString) ?? .undefined
let data = """
["active", "inactive", "foo"]
""".data(using: .utf8)!
let decoded = try! JSONDecoder().decode([State].self, from: data)
print(decoded) // [State.active, State.inactive, State.undefined]
Another lightweight dependency injection through default values for function parameters
Dependency injection boils down to a simple idea: when an object requires a dependency, it shouldn't create it by itself, but instead it should be given a function that does it for him.
Now the great thing with Swift is that, not only can a function take another function as a parameter, but that parameter can also be given a default value.
When you combine both those features, you can end up with a dependency injection pattern that is both lightweight on boilerplate, but also type safe.
import Foundation
protocol Service {
func call() -> String
class ProductionService: Service {
func call() -> String {
return "This is the production"
class MockService: Service {
func call() -> String {
return "This is a mock"
typealias Provider<T> = () -> T
class Controller {
let service: Service
init(serviceProvider: Provider<Service> = { return ProductionService() }) {
self.service = serviceProvider()
func work() {
let productionController = Controller()
productionController.work() // prints "This is the production"
let mockedController = Controller(serviceProvider: { return MockService() })
mockedController.work() // prints "This is a mock"
Lightweight dependency injection through protocol-oriented programming
Singletons are pretty bad. They make your architecture rigid and tightly coupled, which then results in your code being hard to test and refactor. Instead of using singletons, your code should rely on dependency injection, which is a much more architecturally sound approach.
But singletons are so easy to use, and dependency injection requires us to do extra-work. So maybe, for simple situations, we could find an in-between solution?
One possible solution is to rely on one of Swift's most know features: protocol-oriented programming. Using a protocol
, we declare and access our dependency. We then store it in a private singleton, and perform the injection through an extension of said protocol
This way, our code will indeed be decoupled from its dependency, while at the same time keeping the boilerplate to a minimum.
import Foundation
protocol Formatting {
var formatter: NumberFormatter { get }
private let sharedFormatter: NumberFormatter = {
let sharedFormatter = NumberFormatter()
sharedFormatter.numberStyle = .currency
return sharedFormatter
extension Formatting {
var formatter: NumberFormatter { return sharedFormatter }
class ViewModel: Formatting {
var displayableAmount: String?
func updateDisplay(to amount: Double) {
displayableAmount = formatter.string(for: amount)
let viewModel = ViewModel()
viewModel.updateDisplay(to: 42000.45)
viewModel.displayableAmount // "$42,000.45"
[weak self]
and guard
Getting rid of overabundant Callbacks are a part of almost all iOS apps, and as frameworks such as RxSwift
keep gaining in popularity, they become ever more present in our codebase.
Seasoned Swift developers are aware of the potential memory leaks that @escaping
callbacks can produce, so they make real sure to always use [weak self]
, whenever they need to use self
inside such a context. And when they need to have self
be non-optional, they then add a guard
statement along.
Consequently, this syntax of a [weak self]
followed by a guard
rapidly tends to appear everywhere in the codebase. The good thing is that, through a little protocol-oriented trick, it's actually possible to get rid of this tedious syntax, without loosing any of its benefits!
import Foundation
import PlaygroundSupport
PlaygroundPage.current.needsIndefiniteExecution = true
protocol Weakifiable: class { }
extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
func weakify<T>(_ code: @escaping (T, Self) -> Void) -> (T) -> Void {
return { [weak self] arg in
guard let self = self else { return }
code(arg, self)
extension NSObject: Weakifiable { }
class Producer: NSObject {
deinit {
print("deinit Producer")
private var handler: (Int) -> Void = { _ in }
func register(handler: @escaping (Int) -> Void) {
self.handler = handler
DispatchQueue.main.asyncAfter(deadline: .now() + 1.0, execute: { self.handler(42) })
class Consumer: NSObject {
deinit {
print("deinit Consumer")
let producer = Producer()
func consume() {
producer.register(handler: weakify { result, strongSelf in
private func handle(_ result: Int) {
print("🎉 \(result)")
var consumer: Consumer? = Consumer()
DispatchQueue.main.asyncAfter(deadline: .now() + 2.0, execute: { consumer = nil })
// This code prints:
// 🎉 42
// deinit Consumer
// deinit Producer
Solving callback hell with function composition
Asynchronous functions are a big part of iOS APIs, and most developers are familiar with the challenge they pose when one needs to sequentially call several asynchronous APIs.
This often results in callbacks being nested into one another, a predicament often referred to as callback hell.
Many third-party frameworks are able to tackle this issue, for instance RxSwift or PromiseKit. Yet, for simple instances of the problem, there is no need to use such big guns, as it can actually be solved with simple function composition.
import Foundation
typealias CompletionHandler<Result> = (Result?, Error?) -> Void
infix operator ~>: MultiplicationPrecedence
func ~> <T, U>(_ first: @escaping (CompletionHandler<T>) -> Void, _ second: @escaping (T, CompletionHandler<U>) -> Void) -> (CompletionHandler<U>) -> Void {
return { completion in
first({ firstResult, error in
guard let firstResult = firstResult else { completion(nil, error); return }
second(firstResult, { (secondResult, error) in
completion(secondResult, error)
func ~> <T, U>(_ first: @escaping (CompletionHandler<T>) -> Void, _ transform: @escaping (T) -> U) -> (CompletionHandler<U>) -> Void {
return { completion in
first({ result, error in
guard let result = result else { completion(nil, error); return }
completion(transform(result), nil)
func service1(_ completionHandler: CompletionHandler<Int>) {
completionHandler(42, nil)
func service2(arg: String, _ completionHandler: CompletionHandler<String>) {
completionHandler("🎉 \(arg)", nil)
let chainedServices = service1
~> { int in return String(int / 2) }
~> service2
chainedServices({ result, _ in
guard let result = result else { return }
print(result) // Prints: 🎉 21
Transform an asynchronous function into a synchronous one
Asynchronous functions are a great way to deal with future events without blocking a thread. Yet, there are times where we would like them to behave in exactly such a blocking way.
Think about writing unit tests and using mocked network calls. You will need to add complexity to your test in order to deal with asynchronous functions, whereas synchronous ones would be much easier to manage.
Thanks to Swift proficiency in the functional paradigm, it is possible to write a function whose job is to take an asynchronous function and transform it into a synchronous one.
import Foundation
func makeSynchrone<A, B>(_ asyncFunction: @escaping (A, (B) -> Void) -> Void) -> (A) -> B {
return { arg in
let lock = NSRecursiveLock()
var result: B? = nil
asyncFunction(arg) {
result = $0
return result!
func myAsyncFunction(arg: Int, completionHandler: (String) -> Void) {
completionHandler("🎉 \(arg)")
let syncFunction = makeSynchrone(myAsyncFunction)
print(syncFunction(42)) // prints 🎉 42
Using KeyPaths instead of closures
Closures are a great way to interact with generic APIs, for instance APIs that allow to manipulate data structures through the use of generic functions, such as filter()
or sorted()
The annoying part is that closures tend to clutter your code with many instances of {
, }
and $0
, which can quickly undermine its readably.
A nice alternative for a cleaner syntax is to use a KeyPath
instead of a closure, along with an operator that will deal with transforming the provided KeyPath
in a closure.
import Foundation
prefix operator ^
prefix func ^ <Element, Attribute>(_ keyPath: KeyPath<Element, Attribute>) -> (Element) -> Attribute {
return { element in element[keyPath: keyPath] }
struct MyData {
let int: Int
let string: String
let data = [MyData(int: 2, string: "Foo"), MyData(int: 4, string: "Bar")]
data.map(^\.int) // [2, 4]
data.map(^\.string) // ["Foo", "Bar"]
Bringing some type-safety to a Many iOS APIs still rely on a userInfo
to handle use-case specific data. This Dictionary
usually stores untyped values, and is declared as follows: [String: Any]
(or sometimes [AnyHashable: Any]
Retrieving data from such a structure will involve some conditional casting (via the as?
operator), which is prone to both errors and repetitions. Yet, by introducing a custom subscript
, it's possible to encapsulate all the tedious logic, and end-up with an easier and more robust API.
import Foundation
typealias TypedUserInfoKey<T> = (key: String, type: T.Type)
extension Dictionary where Key == String, Value == Any {
subscript<T>(_ typedKey: TypedUserInfoKey<T>) -> T? {
return self[typedKey.key] as? T
let userInfo: [String : Any] = ["Foo": 4, "Bar": "forty-two"]
let integerTypedKey = TypedUserInfoKey(key: "Foo", type: Int.self)
let intValue = userInfo[integerTypedKey] // returns 4
type(of: intValue) // returns Int?
let stringTypedKey = TypedUserInfoKey(key: "Bar", type: String.self)
let stringValue = userInfo[stringTypedKey] // returns "forty-two"
type(of: stringValue) // returns String?
Lightweight data-binding for an MVVM implementation
MVVM is a great pattern to separate business logic from presentation logic. The main challenge to make it work, is to define a mechanism for the presentation layer to be notified of model updates.
RxSwift is a perfect choice to solve such a problem. Yet, some developers don't feel confortable with leveraging a third-party library for such a central part of their architecture.
For those situation, it's possible to define a lightweight Variable
type, that will make the MVVM pattern very easy to use!
import Foundation
class Variable<Value> {
var value: Value {
didSet {
var onUpdate: ((Value) -> Void)? {
didSet {
init(_ value: Value, _ onUpdate: ((Value) -> Void)? = nil) {
self.value = value
self.onUpdate = onUpdate
let variable: Variable<String?> = Variable(nil)
variable.onUpdate = { data in
if let data = data {
variable.value = "Foo"
variable.value = "Bar"
// prints:
// Foo
// Bar
to its fullest
Using The keyword typealias
allows developers to give a new name to an already existing type. For instance, Swift defines Void
as a typealias
of ()
, the empty tuple.
But a less known feature of this mechanism is that it allows to assign concrete types for generic parameters, or to rename them. This can help make the semantics of generic types much clearer, when used in specific use cases.
import Foundation
enum Either<Left, Right> {
case left(Left)
case right(Right)
typealias Result<Value> = Either<Value, Error>
typealias IntOrString = Either<Int, String>
Writing an interruptible overload of Iterating through objects via the forEach(_:)
method is a great alternative to the classic for
loop, as it allows our code to be completely oblivious of the iteration logic. One limitation, however, is that forEach(_:)
does not allow to stop the iteration midway.
Taking inspiration from the Objective-C implementation, we can write an overload that will allow the developer to stop the iteration, if needed.
import Foundation
extension Sequence {
func forEach(_ body: (Element, _ stop: inout Bool) throws -> Void) rethrows {
var stop = false
for element in self {
try body(element, &stop)
if stop {
["Foo", "Bar", "FooBar"].forEach { element, stop in
stop = (element == "Bar")
// Prints:
// Foo
// Bar
Optimizing the use of Functional programing is a great way to simplify a codebase. For instance, reduce
is an alternative to the classic for
loop, without most the boilerplate. Unfortunately, simplicity often comes at the price of performance.
Consider that you want to remove duplicate values from a Sequence
. While reduce()
is a perfectly fine way to express this computation, the performance will be sub optimal, because of all the unnecessary Array
copying that will happen every time its closure gets called.
That's when reduce(into:_:)
comes into play. This version of reduce
leverages the capacities of copy-on-write type (such as Array
or Dictionnary
) in order to avoid unnecessary copying, which results in a great performance boost.
import Foundation
func time(averagedExecutions: Int = 1, _ code: () -> Void) {
let start = Date()
for _ in 0..<averagedExecutions { code() }
let end = Date()
let duration = end.timeIntervalSince(start) / Double(averagedExecutions)
print("time: \(duration)")
let data = (1...1_000).map { _ in Int(arc4random_uniform(256)) }
// runs in 0.63s
time {
let noDuplicates: [Int] = data.reduce([], { $0.contains($1) ? $0 : $0 + [$1] })
// runs in 0.15s
time {
let noDuplicates: [Int] = data.reduce(into: [], { if !$0.contains($1) { $0.append($1) } } )
Avoiding hardcoded reuse identifiers
UI components such as UITableView
and UICollectionView
rely on reuse identifiers in order to efficiently recycle the views they display. Often, those reuse identifiers take the form of a static hardcoded String
, that will be used for every instance of their class.
Through protocol-oriented programing, it's possible to avoid those hardcoded values, and instead use the name of the type as a reuse identifier.
import Foundation
import UIKit
protocol Reusable {
static var reuseIdentifier: String { get }
extension Reusable {
static var reuseIdentifier: String {
return String(describing: self)
extension UITableViewCell: Reusable { }
extension UITableView {
func register<T: UITableViewCell>(_ class: T.Type) {
register(`class`, forCellReuseIdentifier: T.reuseIdentifier)
func dequeueReusableCell<T: UITableViewCell>(for indexPath: IndexPath) -> T {
return dequeueReusableCell(withIdentifier: T.reuseIdentifier, for: indexPath) as! T
class MyCell: UITableViewCell { }
let tableView = UITableView()
let myCell: MyCell = tableView.dequeueReusableCell(for: [0, 0])
Defining a union type
The C language has a construct called union
, that allows a single variable to hold values from different types. While Swift does not provide such a construct, it provides enums with associated values, which allows us to define a type called Either
that implements a union
of two types.
import Foundation
enum Either<A, B> {
case left(A)
case right(B)
func either(ifLeft: ((A) -> Void)? = nil, ifRight: ((B) -> Void)? = nil) {
switch self {
case let .left(a):
case let .right(b):
extension Bool { static func random() -> Bool { return arc4random_uniform(2) == 0 } }
var intOrString: Either<Int, String> = Bool.random() ? .left(2) : .right("Foo")
intOrString.either(ifLeft: { print($0 + 1) }, ifRight: { print($0 + "Bar") })
If you're interested by this kind of data structure, I strongly recommend that you learn more about Algebraic Data Types.
Asserting that classes have associated NIBs and vice-versa
Most of the time, when we create a .xib
file, we give it the same name as its associated class. From that, if we later refactor our code and rename such a class, we run the risk of forgetting to rename the associated .xib
While the error will often be easy to catch, if the .xib
is used in a remote section of its app, it might go unnoticed for sometime. Fortunately it's possible to build custom test predicates that will assert that 1) for a given class, there exists a .nib
with the same name in a given Bundle
, 2) for all the .nib
in a given Bundle
, there exists a class with the same name.
import XCTest
public func XCTAssertClassHasNib(_ class: AnyClass, bundle: Bundle, file: StaticString = #file, line: UInt = #line) {
let associatedNibURL = bundle.url(forResource: String(describing: `class`), withExtension: "nib")
XCTAssertNotNil(associatedNibURL, "Class \"\(`class`)\" has no associated nib file", file: file, line: line)
public func XCTAssertNibHaveClasses(_ bundle: Bundle, file: StaticString = #file, line: UInt = #line) {
guard let bundleName = bundle.infoDictionary?["CFBundleName"] as? String,
let basePath = bundle.resourcePath,
let enumerator = FileManager.default.enumerator(at: URL(fileURLWithPath: basePath),
includingPropertiesForKeys: nil,
options: [.skipsHiddenFiles, .skipsSubdirectoryDescendants]) else { return }
var nibFilesURLs = [URL]()
for case let fileURL as URL in enumerator {
if fileURL.pathExtension.uppercased() == "NIB" {
nibFilesURLs.map { $0.lastPathComponent }
.compactMap { $0.split(separator: ".").first }
.map { String($0) }
.forEach {
let associatedClass: AnyClass? = bundle.classNamed("\(bundleName).\($0)")
XCTAssertNotNil(associatedClass, "File \"\($0).nib\" has no associated class", file: file, line: line)
XCTAssertClassHasNib(MyFirstTableViewCell.self, bundle: Bundle(for: AppDelegate.self))
XCTAssertClassHasNib(MySecondTableViewCell.self, bundle: Bundle(for: AppDelegate.self))
XCTAssertNibHaveClasses(Bundle(for: AppDelegate.self))
Many thanks Benjamin Lavialle for coming up with the idea behind the second test predicate.
Small footprint type-erasing with functions
Seasoned Swift developers know it: a protocol with associated type (PAT) "can only be used as a generic constraint because it has Self or associated type requirements". When we really need to use a PAT to type a variable, the goto workaround is to use a type-erased wrapper.
While this solution works perfectly, it requires a fair amount of boilerplate code. In instances where we are only interested in exposing one particular function of the PAT, a shorter approach using function types is possible.
import Foundation
import UIKit
protocol Configurable {
associatedtype Model
func configure(with model: Model)
typealias Configurator<Model> = (Model) -> ()
extension UILabel: Configurable {
func configure(with model: String) {
self.text = model
let label = UILabel()
let configurator: Configurator<String> = label.configure
label.text // "Foo"
Performing animations sequentially
exposes a very powerful and simple API to perform view animations. However, this API can become a little bit quirky to use when we want to perform animations sequentially, because it involves nesting closure within one another, which produces notoriously hard to maintain code.
Nonetheless, it's possible to define a rather simple class, that will expose a really nicer API for this particular use case
import Foundation
import UIKit
class AnimationSequence {
typealias Animations = () -> Void
private let current: Animations
private let duration: TimeInterval
private var next: AnimationSequence? = nil
init(animations: @escaping Animations, duration: TimeInterval) {
self.current = animations
self.duration = duration
@discardableResult func append(animations: @escaping Animations, duration: TimeInterval) -> AnimationSequence {
var lastAnimation = self
while let nextAnimation = lastAnimation.next {
lastAnimation = nextAnimation
lastAnimation.next = AnimationSequence(animations: animations, duration: duration)
return self
func run() {
UIView.animate(withDuration: duration, animations: current, completion: { finished in
if finished, let next = self.next {
var firstView = UIView()
var secondView = UIView()
firstView.alpha = 0
secondView.alpha = 0
AnimationSequence(animations: { firstView.alpha = 1.0 }, duration: 1)
.append(animations: { secondView.alpha = 1.0 }, duration: 0.5)
.append(animations: { firstView.alpha = 0.0 }, duration: 2.0)
Debouncing a function call
Debouncing is a very useful tool when dealing with UI inputs. Consider a search bar, whose content is used to query an API. It wouldn't make sense to perform a request for every character the user is typing, because as soon as a new character is entered, the result of the previous request has become irrelevant.
Instead, our code will perform much better if we "debounce" the API call, meaning that we will wait until some delay has passed, without the input being modified, before actually performing the call.
import Foundation
func debounced(delay: TimeInterval, queue: DispatchQueue = .main, action: @escaping (() -> Void)) -> () -> Void {
var workItem: DispatchWorkItem?
return {
workItem = DispatchWorkItem(block: action)
queue.asyncAfter(deadline: .now() + delay, execute: workItem!)
let debouncedPrint = debounced(delay: 1.0) { print("Action performed!") }
// After a 1 second delay, this gets
// printed only once to the console:
// Action performed!
Providing useful operators for When we need to apply the standard boolean operators to Optional
booleans, we often end up with a syntax unnecessarily crowded with unwrapping operations. By taking a cue from the world of three-valued logics, we can define a couple operators that make working with Bool?
values much nicer.
import Foundation
func && (lhs: Bool?, rhs: Bool?) -> Bool? {
switch (lhs, rhs) {
case (false, _), (_, false):
return false
case let (unwrapLhs?, unwrapRhs?):
return unwrapLhs && unwrapRhs
return nil
func || (lhs: Bool?, rhs: Bool?) -> Bool? {
switch (lhs, rhs) {
case (true, _), (_, true):
return true
case let (unwrapLhs?, unwrapRhs?):
return unwrapLhs || unwrapRhs
return nil
false && nil // false
true && nil // nil
[true, nil, false].reduce(true, &&) // false
nil || true // true
nil || false // nil
[true, nil, false].reduce(false, ||) // true
Removing duplicate values from a Transforming a Sequence
in order to remove all the duplicate values it contains is a classic use case. To implement it, one could be tempted to transform the Sequence
into a Set
, then back to an Array
. The downside with this approach is that it will not preserve the order of the sequence, which can definitely be a dealbreaker. Using reduce()
it is possible to provide a concise implementation that preserves ordering:
import Foundation
extension Sequence where Element: Equatable {
func duplicatesRemoved() -> [Element] {
return reduce([], { $0.contains($1) ? $0 : $0 + [$1] })
let data = [2, 5, 2, 3, 6, 5, 2]
data.duplicatesRemoved() // [2, 5, 3, 6]
Shorter syntax to deal with optional strings
Optional strings are very common in Swift code, for instance many objects from UIKit
expose the text they display as a String?
. Many times you will need to manipulate this data as an unwrapped String
, with a default value set to the empty string for nil
While the nil-coalescing operator (e.g. ??
) is a perfectly fine way to a achieve this goal, defining a computed variable like orEmpty
can help a lot in cleaning the syntax.
import Foundation
import UIKit
extension Optional where Wrapped == String {
var orEmpty: String {
switch self {
case .some(let value):
return value
case .none:
return ""
func doesNotWorkWithOptionalString(_ param: String) {
// do something with `param`
let label = UILabel()
label.text = "This is some text."
Encapsulating background computation and UI update
Every seasoned iOS developers knows it: objects from UIKit
can only be accessed from the main thread. Any attempt to access them from a background thread is a guaranteed crash.
Still, running a costly computation on the background, and then using it to update the UI can be a common pattern.
In such cases you can rely on asyncUI
to encapsulate all the boilerplate code.
import Foundation
import UIKit
func asyncUI<T>(_ computation: @autoclosure @escaping () -> T, qos: DispatchQoS.QoSClass = .userInitiated, _ completion: @escaping (T) -> Void) {
DispatchQueue.global(qos: qos).async {
let value = computation()
DispatchQueue.main.async {
let label = UILabel()
func costlyComputation() -> Int { return (0..<10_000).reduce(0, +) }
asyncUI(costlyComputation()) { value in
label.text = "\(value)"
Retrieving all the necessary data to build a debug view
A debug view, from which any controller of an app can be instantiated and pushed on the navigation stack, has the potential to bring some real value to a development process. A requirement to build such a view is to have a list of all the classes from a given Bundle
that inherit from UIViewController
. With the following extension
, retrieving this list becomes a piece of cake
import Foundation
import UIKit
import ObjectiveC
extension Bundle {
func viewControllerTypes() -> [UIViewController.Type] {
guard let bundlePath = self.executablePath else { return [] }
var size: UInt32 = 0
var rawClassNames: UnsafeMutablePointer<UnsafePointer<Int8>>!
var parsedClassNames = [String]()
rawClassNames = objc_copyClassNamesForImage(bundlePath, &size)
for index in 0..<size {
let className = rawClassNames[Int(index)]
if let name = NSString.init(utf8String:className) as String?,
NSClassFromString(name) is UIViewController.Type {
return parsedClassNames
.compactMap { NSClassFromString($0) as? UIViewController.Type }
// Fetch all view controller types in UIKit
Bundle(for: UIViewController.self).viewControllerTypes()
I share the credit for this tip with Benoît Caron.
Defining a function to map over dictionaries
Update As it turns out, map
is actually a really bad name for this function, because it does not preserve composition of transformations, a property that is required to fit the definition of a real map
Surprisingly enough, the standard library doesn't define a map()
function for dictionaries that allows to map both keys
and values
into a new Dictionary
. Nevertheless, such a function can be helpful, for instance when converting data across different frameworks.
import Foundation
extension Dictionary {
func map<T: Hashable, U>(_ transform: (Key, Value) throws -> (T, U)) rethrows -> [T: U] {
var result: [T: U] = [:]
for (key, value) in self {
let (transformedKey, transformedValue) = try transform(key, value)
result[transformedKey] = transformedValue
return result
let data = [0: 5, 1: 6, 2: 7]
data.map { ("\($0)", $1 * $1) } // ["2": 49, "0": 25, "1": 36]
A shorter syntax to remove Swift provides the function compactMap()
, that can be used to remove nil
values from a Sequence
of optionals when calling it with an argument that just returns its parameter (i.e. compactMap { $0 }
). Still, for such use cases it would be nice to get rid of the trailing closure.
The implementation isn't as straightforward as your usual extension
, but once it has been written, the call site definitely gets cleaner
import Foundation
protocol OptionalConvertible {
associatedtype Wrapped
func asOptional() -> Wrapped?
extension Optional: OptionalConvertible {
func asOptional() -> Wrapped? {
return self
extension Sequence where Element: OptionalConvertible {
func compacted() -> [Element.Wrapped] {
return compactMap { $0.asOptional() }
let data = [nil, 1, 2, nil, 3, 5, nil, 8, nil]
data.compacted() // [1, 2, 3, 5, 8]
Dealing with expirable values
It might happen that your code has to deal with values that come with an expiration date. In a game, it could be a score multiplier that will only last for 30 seconds. Or it could be an authentication token for an API, with a 15 minutes lifespan. In both instances you can rely on the type Expirable
to encapsulate the expiration logic.
import Foundation
struct Expirable<T> {
private var innerValue: T
private(set) var expirationDate: Date
var value: T? {
return hasExpired() ? nil : innerValue
init(value: T, expirationDate: Date) {
self.innerValue = value
self.expirationDate = expirationDate
init(value: T, duration: Double) {
self.innerValue = value
self.expirationDate = Date().addingTimeInterval(duration)
func hasExpired() -> Bool {
return expirationDate < Date()
let expirable = Expirable(value: 42, duration: 3)
expirable.value // 42
expirable.value // nil
I share the credit for this tip with Benoît Caron.
Using parallelism to speed-up Almost all Apple devices able to run Swift code are powered by a multi-core CPU, consequently making a good use of parallelism is a great way to improve code performance. map()
is a perfect candidate for such an optimization, because it is almost trivial to define a parallel implementation.
import Foundation
extension Array {
func parallelMap<T>(_ transform: (Element) -> T) -> [T] {
let res = UnsafeMutablePointer<T>.allocate(capacity: count)
DispatchQueue.concurrentPerform(iterations: count) { i in
res[i] = transform(self[i])
let finalResult = Array<T>(UnsafeBufferPointer(start: res, count: count))
res.deallocate(capacity: count)
return finalResult
let array = (0..<1_000).map { $0 }
func work(_ n: Int) -> Int {
return (0..<n).reduce(0, +)
array.parallelMap { work($0) }
when the transform
function actually performs some costly computations. Otherwise performances will be systematically slower than using map()
, because of the multithreading overhead.
Measuring execution time with minimum boilerplate
During development of a feature that performs some heavy computations, it can be helpful to measure just how much time a chunk of code takes to run. The time()
function is a nice tool for this purpose, because of how simple it is to add and then to remove when it is no longer needed.
import Foundation
func time(averagedExecutions: Int = 1, _ code: () -> Void) {
let start = Date()
for _ in 0..<averagedExecutions { code() }
let end = Date()
let duration = end.timeIntervalSince(start) / Double(averagedExecutions)
print("time: \(duration)")
time {
(0...10_000).map { $0 * $0 }
// time: 0.183973908424377
Running two pieces of code in parallel
Concurrency is definitely one of those topics were the right encapsulation bears the potential to make your life so much easier. For instance, with this piece of code you can easily launch two computations in parallel, and have the results returned in a tuple.
import Foundation
func parallel<T, U>(_ left: @autoclosure () -> T, _ right: @autoclosure () -> U) -> (T, U) {
var leftRes: T?
var rightRes: U?
DispatchQueue.concurrentPerform(iterations: 2, execute: { id in
if id == 0 {
leftRes = left()
} else {
rightRes = right()
return (leftRes!, rightRes!)
let values = (1...100_000).map { $0 }
let results = parallel(values.map { $0 * $0 }, values.reduce(0, +))
Making good use of #file, #line and #function
Swift exposes three special variables #file
, #line
and #function
, that are respectively set to the name of the current file, line and function. Those variables become very useful when writing custom logging functions or test predicates.
import Foundation
func log(_ message: String, _ file: String = #file, _ line: Int = #line, _ function: String = #function) {
print("[\(file):\(line)] \(function) - \(message)")
func foo() {
log("Hello world!")
foo() // [MyPlayground.playground:8] foo() - Hello world!
Comparing Optionals through Conditional Conformance
Swift 4.1 has introduced a new feature called Conditional Conformance, which allows a type to implement a protocol only when its generic type also does.
With this addition it becomes easy to let Optional
implement Comparable
only when Wrapped
also implements Comparable
import Foundation
extension Optional: Comparable where Wrapped: Comparable {
public static func < (lhs: Optional, rhs: Optional) -> Bool {
switch (lhs, rhs) {
case let (lhs?, rhs?):
return lhs < rhs
case (nil, _?):
return true // anything is greater than nil
case (_?, nil):
return false // nil in smaller than anything
case (nil, nil):
return true // nil is not smaller than itself
let data: [Int?] = [8, 4, 3, nil, 12, 4, 2, nil, -5]
data.sorted() // [nil, nil, Optional(-5), Optional(2), Optional(3), Optional(4), Optional(4), Optional(8), Optional(12)]
Safely subscripting a Collection
Any attempt to access an Array
beyond its bounds will result in a crash. While it's possible to write conditions such as if index < array.count { array[index] }
in order to prevent such crashes, this approach will rapidly become cumbersome.
A great thing is that this condition can be encapsulated in a custom subscript
that will work on any Collection
import Foundation
extension Collection {
subscript (safe index: Index) -> Element? {
return indices.contains(index) ? self[index] : nil
let data = [1, 3, 4]
data[safe: 1] // Optional(3)
data[safe: 10] // nil
Easier String slicing using ranges
Subscripting a string with a range can be very cumbersome in Swift 4. Let's face it, no one wants to write lines like someString[index(startIndex, offsetBy: 0)..<index(startIndex, offsetBy: 10)]
on a regular basis.
Luckily, with the addition of one clever extension, strings can be sliced as easily as arrays
import Foundation
extension String {
public subscript(value: CountableClosedRange<Int>) -> Substring {
get {
return self[index(startIndex, offsetBy: value.lowerBound)...index(startIndex, offsetBy: value.upperBound)]
public subscript(value: CountableRange<Int>) -> Substring {
get {
return self[index(startIndex, offsetBy: value.lowerBound)..<index(startIndex, offsetBy: value.upperBound)]
public subscript(value: PartialRangeUpTo<Int>) -> Substring {
get {
return self[..<index(startIndex, offsetBy: value.upperBound)]
public subscript(value: PartialRangeThrough<Int>) -> Substring {
get {
return self[...index(startIndex, offsetBy: value.upperBound)]
public subscript(value: PartialRangeFrom<Int>) -> Substring {
get {
return self[index(startIndex, offsetBy: value.lowerBound)...]
let data = "This is a string!"
data[..<4] // "This"
data[5..<9] // "is a"
data[10...] // "string!"
Concise syntax for sorting using a KeyPath
By using a KeyPath
along with a generic type, a very clean and concise syntax for sorting data can be implemented:
import Foundation
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { $0[keyPath: attribute] < $1[keyPath: attribute] })
let data = ["Some", "words", "of", "different", "lengths"]
data.sorted(by: \.count) // ["of", "Some", "words", "lengths", "different"]
If you like this syntax, make sure to checkout KeyPathKit!
Manufacturing cache-efficient versions of pure functions
By capturing a local variable in a returned closure, it is possible to manufacture cache-efficient versions of pure functions. Be careful though, this trick only works with non-recursive function!
import Foundation
func cached<In: Hashable, Out>(_ f: @escaping (In) -> Out) -> (In) -> Out {
var cache = [In: Out]()
return { (input: In) -> Out in
if let cachedValue = cache[input] {
return cachedValue
} else {
let result = f(input)
cache[input] = result
return result
let cachedCos = cached { (x: Double) in cos(x) }
cachedCos(.pi * 2) // value of cos for 2π is now cached
Simplifying complex conditions with pattern matching
When distinguishing between complex boolean conditions, using a switch
statement along with pattern matching can be more readable than the classic series of if {} else if {}
import Foundation
let expr1: Bool
let expr2: Bool
let expr3: Bool
if expr1 && !expr3 {
} else if !expr2 && expr3 {
} else if expr1 && !expr2 && expr3 {
switch (expr1, expr2, expr3) {
case (true, _, false):
case (_, false, true):
case (true, false, true):
Easily generating arrays of data
Using map()
on a range makes it easy to generate an array of data.
import Foundation
func randomInt() -> Int { return Int(arc4random()) }
let randomArray = (1...10).map { _ in randomInt() }
Using @autoclosure for cleaner call sites
Using @autoclosure
enables the compiler to automatically wrap an argument within a closure, thus allowing for a very clean syntax at call sites.
import UIKit
extension UIView {
class func animate(withDuration duration: TimeInterval, _ animations: @escaping @autoclosure () -> Void) {
UIView.animate(withDuration: duration, animations: animations)
let view = UIView()
UIView.animate(withDuration: 0.3, view.backgroundColor = .orange)
Observing new and old value with RxSwift
When working with RxSwift, it's very easy to observe both the current and previous value of an observable sequence by simply introducing a shift using skip()
import RxSwift
let values = Observable.of(4, 8, 15, 16, 23, 42)
let newAndOld = Observable.zip(values, values.skip(1)) { (previous: $0, current: $1) }
.subscribe(onNext: { pair in
print("current: \(pair.current) - previous: \(pair.previous)")
//current: 8 - previous: 4
//current: 15 - previous: 8
//current: 16 - previous: 15
//current: 23 - previous: 16
//current: 42 - previous: 23
Implicit initialization from literal values
Using protocols such as ExpressibleByStringLiteral
it is possible to provide an init
that will be automatically when a literal value is provided, allowing for nice and short syntax. This can be very helpful when writing mock or test data.
import Foundation
extension URL: ExpressibleByStringLiteral {
public init(stringLiteral value: String) {
self.init(string: value)!
let url: URL = "http://www.google.fr"
NSURLConnection.canHandle(URLRequest(url: "http://www.google.fr"))
Achieving systematic validation of data
Through some clever use of Swift private
visibility it is possible to define a container that holds any untrusted value (such as a user input) from which the only way to retrieve the value is by making it successfully pass a validation test.
import Foundation
struct Untrusted<T> {
private(set) var value: T
protocol Validator {
associatedtype T
static func validation(value: T) -> Bool
extension Validator {
static func validate(untrusted: Untrusted<T>) -> T? {
if self.validation(value: untrusted.value) {
return untrusted.value
} else {
return nil
struct FrenchPhoneNumberValidator: Validator {
static func validation(value: String) -> Bool {
return (value.count) == 10 && CharacterSet(charactersIn: value).isSubset(of: CharacterSet.decimalDigits)
let validInput = Untrusted(value: "0122334455")
let invalidInput = Untrusted(value: "0123")
FrenchPhoneNumberValidator.validate(untrusted: validInput) // returns "0122334455"
FrenchPhoneNumberValidator.validate(untrusted: invalidInput) // returns nil
Implementing the builder pattern with keypaths
With the addition of keypaths in Swift 4, it is now possible to easily implement the builder pattern, that allows the developer to clearly separate the code that initializes a value from the code that uses it, without the burden of defining a factory method.
import UIKit
protocol With {}
extension With where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>, setTo value: T) -> Self {
self[keyPath: property] = value
return self
extension UIView: With {}
let view = UIView()
let label = UILabel()
.with(\.textColor, setTo: .red)
.with(\.text, setTo: "Foo")
.with(\.textAlignment, setTo: .right)
.with(\.layer.cornerRadius, setTo: 5)
for an unavailable property will result in a runtime crash.
I share the credit for this tip with Marion Curtil.
Storing functions rather than values
When a type stores values for the sole purpose of parametrizing its functions, it's then possible to not store the values but directly the function, with no discernable difference at the call site.
import Foundation
struct MaxValidator {
let max: Int
let strictComparison: Bool
func isValid(_ value: Int) -> Bool {
return self.strictComparison ? value < self.max : value <= self.max
struct MaxValidator2 {
var isValid: (_ value: Int) -> Bool
init(max: Int, strictComparison: Bool) {
self.isValid = strictComparison ? { $0 < max } : { $0 <= max }
MaxValidator(max: 5, strictComparison: true).isValid(5) // false
MaxValidator2(max: 5, strictComparison: false).isValid(5) // true
Defining operators on function types
Functions are first-class citizen types in Swift, so it is perfectly legal to define operators for them.
import Foundation
let firstRange = { (0...3).contains($0) }
let secondRange = { (5...6).contains($0) }
func ||(_ lhs: @escaping (Int) -> Bool, _ rhs: @escaping (Int) -> Bool) -> (Int) -> Bool {
return { value in
return lhs(value) || rhs(value)
(firstRange || secondRange)(2) // true
(firstRange || secondRange)(4) // false
(firstRange || secondRange)(6) // true
Typealiases for functions
Typealiases are great to express function signatures in a more comprehensive manner, which then enables us to easily define functions that operate on them, resulting in a nice way to write and use some powerful API.
import Foundation
typealias RangeSet = (Int) -> Bool
func union(_ left: @escaping RangeSet, _ right: @escaping RangeSet) -> RangeSet {
return { left($0) || right($0) }
let firstRange = { (0...3).contains($0) }
let secondRange = { (5...6).contains($0) }
let unionRange = union(firstRange, secondRange)
unionRange(2) // true
unionRange(4) // false
Encapsulating state within a function
By returning a closure that captures a local variable, it's possible to encapsulate a mutable state within a function.
import Foundation
func counterFactory() -> () -> Int {
var counter = 0
return {
counter += 1
return counter
let counter = counterFactory()
counter() // returns 1
counter() // returns 2
Generating all cases for an Enum
⚠ Since Swift 4.2,allCases
can now be synthesized at compile-time by simply conforming to the protocolCaseIterable
. The implementation below should no longer be used in production code.
Through some clever leveraging of how enums are stored in memory, it is possible to generate an array that contains all the possible cases of an enum. This can prove particularly useful when writing unit tests that consume random data.
import Foundation
enum MyEnum { case first; case second; case third; case fourth }
protocol EnumCollection: Hashable {
static var allCases: [Self] { get }
extension EnumCollection {
public static var allCases: [Self] {
var i = 0
return Array(AnyIterator {
let next = withUnsafePointer(to: &i) {
$0.withMemoryRebound(to: Self.self, capacity: 1) { $0.pointee }
if next.hashValue != i { return nil }
i += 1
return next
extension MyEnum: EnumCollection { }
MyEnum.allCases // [.first, .second, .third, .fourth]
Using map on optional values
The if-let syntax is a great way to deal with optional values in a safe manner, but at times it can prove to be just a little bit to cumbersome. In such cases, using the Optional.map()
function is a nice way to achieve a shorter code while retaining safeness and readability.
import UIKit
let date: Date? = Date() // or could be nil, doesn't matter
let formatter = DateFormatter()
let label = UILabel()
if let safeDate = date {
label.text = formatter.string(from: safeDate)
label.text = date.map { return formatter.string(from: $0) }
label.text = date.map(formatter.string(from:)) // even shorter, tough less readable


text:
Product Description
Topics Covered: Jazz Composition, Motivations, Techniques, Harmony, Melody, Form, Movement, Harmonizing Scales, Voicings, Etc.
$9.99 – $19.99
"David Hazeltine is for sure the brightest star on the jazz piano horizon. His style has a deep-seated commitment to jazz history while communicating a wealth of today's ideas…" – Cedar Walton
DAVID HAZELTINE is one of a handful of young pianists who has successfully forged his own distinctive style and musical voice out of the accumulated greatness and weight of a modern piano tradition. David's influences extend from Art Tatum and Bud Powell to such great living masters as Buddy Montgomery, Barry Harris and Cedar Walton.
David made his professional debut at age thirteen in Milwaukee, and later worked extensively in and around Chicago and Minneapolis. In Milwaukee, David served as house pianist at the famed Milwaukee Jazz Gallery, working with such greats as Charles McPherson, Eddie Harris, Sonny Stitt, Pepper Adams and Chet Baker. In fact, it was Baker who encouraged David to make his mark in New York City.
Since moving to New York City in 1992, David has made a name for himself as a "musician's musician." In addition to his working trio (with drum legend Louis Hayes and bassist Peter Washington), David is in constant demand as a sideman. Recent credits include work with Freddie Hubbard, James Moody, the Faddis-Hampton-Heath Sextet, the Carnegie Hall Jazz Band, the Louis Hayes Quintet, and Marlena Shaw, for whom he serves as pianist, arranger, and musical director.
Recently David was spotlighted on Marian McPartland's "Piano Jazz" radio program. David is also a member of the band "One For All" which features rising tenor star Eric Alexander.
David's debut cd as a leader Four Flights Up (featuring Slide Hampton,) released in 1996 on the Sharp Nine Label, received high praise from critics and musicians alike. Since then, he has recorded seven more cds for Sharp Nine, the latest being The Inspiration Suite. David has also recorded six cds for the Criss Cross label, the most recent being Blues Quarters Volume 2. In Japan, David's six piano trio releases for the Venus label, including tributes to Bill Evans, Horace Silver, Bud Powell, and Burt Bacharach, have won him a large and growing following.
In addition to David's twenty three dates as a leader, his recorded work as a featured sideman reflects his status as one of the first call pianists in New York. Recent efforts include sessions with James Moody, Freddy Cole, Marlena Shaw, Jon Faddis, and Louis Hayes.
As a dedicated teacher, Hazeltine's career reflects his intense commitment to the advancement of jazz culture and awareness. In Milwaukee, he was co-founder and director of The Jazz School, and Department Chairman at the Wisconsin Conservatory of Music. Recently, he served as Associate Professor at Berklee College Of Music. Currently, David is on the piano faculty at S.U.N.Y. Purchase.
Perhaps David best sums up his feelings about his art and his career: "… the development of the body of music we call jazz is one of the marvels of the 20th century. To contribute to that tradition is all I want to do."


text:
Monica Guggisberg and Philip Baldwin
Monica Guggisberg and Philip Baldwin have been working as a team since 1980. For twenty years they had their studio in Switzerland, and in 2001 they moved to Paris. Independent artists and designers, working principally in glass, they concentrate on one of a kind vessels, larger sculptural works and installations for public spaces. They have received many design and art awards and published several books. Their work is in private collections and museums worldwide.
The vessel goes to the essential heart of their work. "It's that most serene place where we may repose and gaze out at the world. And at the same time it's the place where we make the most cutting edge experiments in what we do."
"For twelve years we have been combining Italian cold-worked cutting techniques with Swedish blown glass color underlay and overlay. Originally inspired by Carlo Scarpa's work with Venini in the 1930's and 40's, we have taken 'battuto' where – to the best of our knowledge – no one else has gone: cutting through the thin layers of color, revealing the colors underneath, weaving pattern and color on the one hand, form and texture on the other. It may reflect images found elsewhere in the world, in walls, in fields, in the bark of a tree, in a river flowing downstream at twilight. Or perhaps nothing at all – pure abstraction of geometry and color.
"A famous artist has said, "I have no favorite color, I have come to love them all." So have we. And, we remain dedicated to simplicity of shape and line, a clean crisp form gleaming."


text:
The Okanagan Water Stewardship Council ("the Council" or OWSC) was established in 2006 as a technical advisory body to the OBWB. The 28 member Council is a diverse group of water stakeholders who meet monthly to provide independent advice and policy recommendations for sustainable water management.
The monthly Council Report highlights current activities, projects and emerging issues.
Please feel free to share widely!


text:
NDT Instruments is a FOERSTER subsidiary established in 1993 with the mission to identify, source and supply quality products and after-sales maintenance, repair calibration services to our customers in the field of Non - Destructive Testing (NDT) and Quality Assurance & Control (QA/QC). Since it started its operations 21 years ago, our customers are discerning buyers who demand value in the form of quality at a competitive price.
We are committed to be the leading supplier in the ASEAN region to provide the most reliable yet cost effective inspection, quality assurance and control related equipment and solutions to our highly value customers.
NDT Instruments Pte Ltd offers the following products:
- Eddy Current Equipment & In-line Systems
- Ultrasonic Equipment & Systems
- Magnetic Particle / Penetrant Inspection Equipment & Systems
- Radiography Equipment & Systems
- Thermography Systems
- Visual Inspection tools and 3D scanners
- Instruments for the determination of electromagnetic material properties
NDT Instruments Pte Ltd
50 Ubi Avenue 3
#05-20 Frontier Building
Singapore 408866
t (65) 6571 0668
f (65) 6571 0669
Plan your visit with Google Maps
> Directions on Google MapsJl. Sirsak / Casamora BB-1, Jagakarsa
Jakarta Selatan 12630
t (62) 21 2943 0001 (Hunting)
f (62) 21 2943 0006
Plan your visit with Google Maps
> Directions on Google MapsBatam Branch
Ruko Mega Legenda 2
Blok E2 No.1, Batam Kota 29431
t (62) 778 7483 403
f (62) 778 7483 401
E-Mail: sales_ID(at)ndt-instruments.com
NDT Indonesia BATAM branch
Plan your visit with Google Maps
> Directions on Google MapsPortfolio
Reformer tube inspection
- External tube inspection (LEO-Scan)
- Internal tube inspection(LEO-iScan)
- Outlet pigtail measurement
- Top end inspection
- Remaining Life Assessment (RLA)
PT. Profluid, Indonesia
Jl. Chairil Anwar Ruko Kalimas Blok D No. 19,
Bekasi Timur, Indonesia
t +62 21 8835 1382
f +62 21 8834 3949
Contact Person: Aris Kusmanto
Plan your visit with Google Maps
> Directions on Google Maps


text:
Last night I had a little play with some crochet and cross-stitch. I can't wait to do more…. think of all the possibilities.
This afternoon has been pretty exciting with a load of pea straw being dropped off at the front door. My wire dress can't stop itself from looking. I am going to do some straw bale vegetable gardening - google it if you haven't heard of it. I'll show photos as I go along but being a beginner, my explanation is bound to be less than satisfactory.
And can you believe that it is that time of the year again - next week sees me setting up the house for my annual Christmas studio sale. Or as I wrote on the flyer, my stuido sale. Just love a good typo, don't you….Lots and lots of love,
Kate Bruning.
p.s. If you are in the Tauranga area, email me and I will send you the details for the sale.


text:
Add New Project
From our project, we plan to design a connection between kids and parents. Our concept is implementing the actions, imaging, or other soft communications instead of sounds. We also plan to make this subtle communication spooky and deliver care for people.
in Intelligent Environments Media Design Physical Computing
2 418 0 0
We wanted to foster more conversations between the Pittsburgh community, visitors, and the hill district community. Memorialize the community space, items and people who were displaced, through a mixed media light display and projection technology triggered by tiles.
in Physical Computing Intelligent Environments
3 584 0 0