FLOSS Project Planets

KDevelop - possibly new release coordinator

Planet KDE - Thu, 2019-11-21 19:00


After many days and weeks of thinking and waiting for better person to appear (nobody appeared) I decided to take the initiative (it took a lot) and try my luck at becoming new KDevelop release coordinator.

My reasoning as I mentioned in my mail is that if there was someone better for the job the position would be filled by now. And I wish for KDevelop to be a healthy project which can rival those monsters like MSVS, NetBeans, Eclipse, Atom, MSVC…

I have a lot to learn, try and prepare before actually becoming official person behind this nice (cute) software. So it will take a while to see me as real KDevelop official.

PS: I might be clumsy but I will do my best.

Categories: FLOSS Project Planets

Palantir: The Wisconsin Department of Employee Trust Funds

Planet Drupal - Thu, 2019-11-21 16:14

Re-platforming the Wisconsin Department of Employee Trust Funds website from HTML templates to Drupal 8, including a complete visual and user experience redesign.

etf.wi.gov An Effortless Customer Experience for Wisconsin Government Employees, Retirees, and Employers On

The Wisconsin Department of Employee Trust Funds (ETF) is responsible for managing the pension and other retirement benefits of over 630,000 state and local government employees and retirees in the state of Wisconsin. With approximately $98 billion in assets, the Wisconsin Retirement System is the 8th largest U.S. public pension fund and the 25th largest public or private pension fund in the world.

In addition to overseeing the Wisconsin Retirement System, ETF also provides benefits such as group health insurance, disability benefits, and group life insurance. Over a half-million people rely on the information ETF provides in order to make decisions that impact not only themselves, but their children, and their children’s children.

The Challenge

Given the extent of services provided by ETF, their website is large and complex with a wealth of vital information. When ETF first approached Palantir.net, their website (shown) hadn't been updated since the early 2000s, and it lacked a content management system. The site wasn’t accessible, it wasn’t responsive, and its overall user experience needed a drastic overhaul. 

Simply put, Wisconsin government employees could not easily navigate the crucial information they need to understand and make decisions about the benefits that they earn.

The new ETF site should lower customer effort across all touchpoints. An effortless customer experience: One stop, fewer clicks and increased satisfaction.

ETF's vision
Key Outcomes

ETF engaged Palantir to re-platform their website from HTML templates to the Drupal 8 content management system, including a complete visual and user experience redesign. After partnering with Palantir, the new user-friendly ETF site:

  • Provides ETF staff and all website visitors with a seamless experience
  • Allows Wisconsin government employees, retirees, and employers to efficiently access accurate and current information
  • Incorporates best practices for content publication for the ETF digital team
Upgrade to the Employee Benefits Explorer

One of the most notable features of the new site is ETF’s Benefits Explorer.

An important function of the ETF site is offering information regarding pension, health insurance, and other benefits. On ETF’s old site, employees were required to select cumbersome and confusing benefit options before they could find detailed information about their benefits. This task was made even more difficult by the fact that the names of benefit options are not descriptive or intuitive. ETF’s previous solution was to send physical mailers with distinctive photos on the covers, and then direct visitors to the website to select the benefit options that had the same image as their mailer.

Palantir and ETF knew that the “find my benefits” user experience needed a complete overhaul. In our initial onsite, we identified a potential solution: creating a database of employers and the benefit options they offer. With this list we built a benefits explorer tool that allows ETF’s customers to search for benefits by the one piece of information they will always definitely have: the name of their employer.

With the new explorer experience, site visitors begin by typing in the name of their employer and are immediately provided with their benefit options. We built two versions of the tool: one for the specific task of identifying health plan options, which are typically decided once a year during open enrollment, and one for identifying all benefits offered by your employer, which can be used any time of year.

The new “My Benefits” explorer is now the second most visited page on the new ETF site, which shows just how helpful this new feature is for ETF’s customers.

How We Did It

In order to transform the ETF website into an effortless experience for Wisconsin government employees, retirees, and employers, there were five critical elements to consider.

Our approach involved:

  1. Identifying “Top Tasks”
  2. Revising content
  3. User-testing the information architecture
  4. Crafting an accessible, responsive design
  5. Replatforming on a robust Content Management System: Drupal

Identifying “Top Tasks”

The biggest negative factor of the previous ETF site’s user experience was its confusing menus. The site presented too many options and pathways for people to find information such as which health insurance plan they belong to or how to apply for retirement benefits, and the pathways often led to different pages about the same topic. Frequently, people would give up or call customer support, which is only open during typical business hours.

Palantir knew the redesign would have the most impact if the site was restructured to fit the needs of ETF’s customers. In order to guarantee we were addressing customers’ most important needs, we used the Top Task Identification methodology developed by customer experience researcher and advocate Gerry McGovern.

Through the use of this method, we organized ETF’s content by the tasks site users deemed most important, with multiple paths to get to content through their homepage, site and organic search, and related content.

Revising Content

Our goal was to make content findable by both internal and external search engines. No matter what page a visitor enters the site on, the page should make sense and the visitor should be able to find their way to more information.

While the Palantir team was completing the Top Tasks analysis, the internal ETF team revised the website content by focusing on:

  • Plain language: ETF had convened a “Plain Language” initiative before engaging with Palantir, and that team was dedicated to transforming the tone of ETF’s content from stiff, formal legalese to a friendlier, more accessible tone.
  • “Bite, snack, meal” content writing strategy: The ETF team used this strategy to “chunk” their content for different levels of user engagement. A bite is a headline with a message, a snack is a short summary of the main points, and a meal is a deep dive into the details.
  • Improving metadata for accessibility and search: Palantir provided guidance on standardizing metadata, particularly for ETF’s PDF library. The ETF content team made sure that all their content had appropriate metadata.

User-tested Information Architecture (IA)

Once we had the results from our Top Tasks study, we worked toward designing a menu organized intuitively for customers. In our initial onsite, we conducted an open card sort with about 40 ETF stakeholders. Our goal was to have the ETF site content experts experiment with ways to improve the labelling, grouping, and organization of the content on their site.

We divided the stakeholders into six teams of five and gave them a set of 50 cards featuring representative content on their site. The ideas our teams generated fell largely into two groups:

  • Audience-oriented: content is organized by the role/title/person who uses it. In this approach, main menu terms might include Retiree, Member, and Employer. This approach was how ETF had content organized on their site at the time of the exercise.
  • Task-oriented: content is organized by the type of task the content relates to. In this approach, main menu terms might include Benefits, Retirement, and Member Education.

When we came back together as a group, our team of 40 stakeholders agreed that exploring a task-based information architecture would be worthwhile, but there was significant concern that switching away from an audience-based IA would confuse their customers.

Since making the site easy to use was one of our top project goals, our teams agreed to a rigorous IA testing approach. We agreed to conduct two rounds of tree tests on both an audience-oriented and task-oriented IA, and conduct three additional rounds of tests to refine the chosen approach.

Ultimately, our tests showed that the most intuitive way to organize the content for ETF’s range of customers was to organize by task, with one significant exception: Employers. ETF serves the human resources teams of all state of Wisconsin employers, and those users had completely separate content requirements from those of government employees and retirees.

Responsive Design System on Drupal

Because the former ETF site was significantly outdated, it completely lacked a content model, and the site itself was a massive hodgepodge of design elements. Palantir identified key ETF user flows, matched the content to each flow, and then abstracted out templates to serve each flow.

The overarching goal of this design system is to create intuitive, repeatable user flows through the website. These patterns enable visitors to quickly scan for the information they need, and make quick decisions about where to go next.

Accessibility and responsiveness are core requirements for ETF. Palantir used the a11y checklist from the very beginning of our design process, and continuously tested our visual designs for font size, color contrast, and general spacing of elements to ensure that accessibility was built into our design rather than retrofitted at the end.

We also conducted usability tests with real users, which helped us make accessibility improvements that accessibility checkers missed. In addition, the new design system is also fully responsive, which enables ETF’s customers to access the site from any device.

Robust Content Management

In addition to the efficiencies gained for site visitors, the new Drupal 8 site streamlines the content management process for the internal ETF site admin team. Previously, content creation happened across people and departments with minimal editorial guidelines. Once the copy was approved internally, the new content was handed to the webmaster for inclusion on the site. The process for updating content frequently took weeks.

With their new Drupal 8 platform, the ETF team has moved to a distributed authorship workflow, underpinned by the Workbench suite of modules which allows for editorial/publishing permissions. Now, ETF subject matter experts can keep their own content up to date while following established standards and best practices. The decision to publish content is still owned by a smaller group, to ensure that only approved and correct content is uploaded to the live site.

The Results

With the fully responsive design system in place, the new ETF site offers a significantly upgraded user experience for their customers:

  • Task-oriented: Our data-based top tasks approach ensured that we kept the focus on the user’s journey through the site. Everything from the menus to the page-level strategy to the visual design was geared towards making it effortless for visitors to achieve their most important tasks.
  • Structured content: Not only has the website’s content been rewritten to be more scannable for readers, but it’s also now structured for SEO. Our initial user research uncovered search as one of the most frustrating aspects of the site: “The main thing for me is really the search results: the most up to date version is never the first thing that turns up” By adding metadata to ETF’s library of PDF forms and transforming their content from freeform text to structured data, ETF’s search experience has made a complete turnaround.
  • User testing: Our strategy and design work was validated throughout the engagement with real site users, which kept us all grounded in the outcomes.
  • Accessible and responsive design: The design system isn’t just WCAG A.A compliant according to accessibility testing software - we worked with users to ensure that the site delivers a good experience with site readers. Incorporating a11y standards from the very beginning of the design process ensured that accessibility was baked into our design rather than a last-minute add on.

Palantir created a task-based navigation and content organization to support the customer journey, which is contributing to a better user experience. The new site is more personalized and engaging for customers.

Mark Lamkins

Director, Office of Communications

Awards NGAW 2019 Pinnacle Award Awarded September 23, 2019 in the State/Federal category.

The NAGW Pinnacles Awards are judged by a group of web professionals inside and outside of the government web industry and are awarded to the best entries based on the following judging criteria: team size, content, organization, design, performance and flexibility, accessibility, standards, interactivity, open data, and responsive design.

DRIVENxDESIGN 2019 GOV Design Award Awarded November 21, 2019 for digital government services.

The DRIVENxDESIGN GOV Design Awards celebrate the courage of both commissioners and creators design projects within the government, community and public sectors. Nominations are across space, object, visual and experience design categories, culminating in the best project, best transformation and best innovation awards.

Re-platforming the ETF site from HTML templates to Drupal 8
Categories: FLOSS Project Planets

Hook 42: Attending DrupalCon Amsterdam 2019

Planet Drupal - Thu, 2019-11-21 14:20
Attending DrupalCon Amsterdam 2019 Lindsey Gemmill Thu, 11/21/2019 - 19:20
Categories: FLOSS Project Planets

Python Anywhere: System update on 21 November 2019

Planet Python - Thu, 2019-11-21 12:40

This morning's system update went smoothly; some websites did take a bit longer than we expected to start up afterwards, but all is well now.

There are two big new features that we have introduced which are going through some final post-deploy tests before they go live -- a new system image (called fishnchips) to support Python 3.8 and to add on a number of extra OS packages that people have been asking us for, and an update to our virtualization system that will fix a number of problems with specific programs. We'll be posting more about those when they're ready to go live.

But there were a number of other things we added:

  • We've added the ability to restart an always-on task without stopping it, waiting for it to stop, and then starting it again -- there's a new "restart" button on the far right of the tasks table.
  • You can now temporarily disable a website without deleting it -- the button is near the bottom of the "Web" page.
  • And, of course, the normal set of minor tweaks, bugfixes, and the like.

Happy coding!

Categories: FLOSS Project Planets

PyCharm: PyCharm 2019.3 Release Candidate

Planet Python - Thu, 2019-11-21 12:07

The release of PyCharm 2019.3 is right around the corner and we’re excited to announce we now have available a release candidate version. Check it out by downloading it from our website!

Improvements in this version
  • We’ve solved the issues causing remote interpreters to take a considerable amount of time and take up a lot of space while running commands. With this version expect remote interpreter usage to be less time and space consuming.
  • The visualization of executed cells for Jupyter Notebooks was improved. In the past, executing a cell might caused some misplacement by scrolling out of the result view that corresponded to the executed cell and that is no longer an issue.
  • A regression issue that caused the debugger not to work properly when special characters were used in the paths of files was fixed.
  • This version makes also the Run | Attach to Process action to be compatible with Python 3.8. If you’re running local processes with Python 3.8 you can now use the debugger capabilities the same way you usually do it in PyCharm.

Read the release notes to learn more.


Download the RC from our website. Alternatively, you can use the JetBrains Toolbox App to stay up to date.

If you’re on Ubuntu 16.04 or later, you can use snap to get PyCharm RC versions, and stay up to date. You can find the installation instructions on our website.

The release candidate (RC) is not an early access program (EAP) build, and does not bundle an EAP license. If you get PyCharm Professional Edition RC, you will either need a currently active PyCharm subscription, or you will receive a 30-day free trial.

Categories: FLOSS Project Planets

Texas Creative: An Account Manager Girl in a Web Developer World

Planet Drupal - Thu, 2019-11-21 10:30

A few weeks ago I had the privilege of attending Texas Camp with the web team here at Texas Creative. Texas Camp is a day of curated sessions and panel conversations, and is hosted by volunteers from the regional Drupal community. I know what you’re thinking, why would an Account Manager go to a day-long session about web development? Well, 1. Websites are secretly (probably not-so secret to some of my co-workers) my favorite projects to work on and 2. I personally think that it benefits everyone (both clients and agency employees) to learn as much as possible in the ever-changing digital space.

Read More
Categories: FLOSS Project Planets

The Digital Cat: Punch 2.0.0 is out

Planet Python - Thu, 2019-11-21 10:00

Punch 2.0.0 is out!

This is the latest release of the project that I started to replace bumpversion. Update your version while having a drink!

Punch is a configurable version updater, and you can use to automate the management of your project’s version number.


  • DEPRECATION Punch doesn't support GLOBAL variables in the FILES variable anymore. The values given to fields in the FILES section are now simple strings and are not processed through Jinja2 anymore.
  • Initial drop of Python 2.x: the CI process doesn't test Python2.x anymore.
  • Complete review of documentation: the docs have been split in multiple files to make it easier to find information and to understand the program.
  • Initial implementation of automatic documentation from tests. Integration tests can now be parsed to extract examples for the documentation. See Examples from the tests
  • Named serializers: serializers now can be given a name through a dictionary syntax. With this change it becomes possible to select the serializer to use for the VCS. See Configuration > GLOBALS
  • Complex serializers: standard serializers use the same pattern both for the search and for the replace actions. With complex serializers you can define two different patterns, one for each action. See Advanced configuration > Complex serializers
  • The configuration of each file managed by Punch can override the global serializers or add new ones. See Configuration > FILES
  • Release notes: Punch can be configured to check if a pattern based on the new version is present in the managed files. This makes it simple to check if HISTORY files have been updated without requiring to interrupt the execution of the program and later restore it. See Advanced configuration > Release notes

Read the full documentation here

Categories: FLOSS Project Planets

Centarro: Querying Drupal Search API indexes using JSON:API

Planet Drupal - Thu, 2019-11-21 09:37

I'm happy to introduce a new module created in my research and development time at Centarro. The JSON:API Search API integration module enables decoupled Drupal architectures to use the Search API module to query indexed data. Before diving into the module, I want to explore the problem space it aims to solve.

Categories: FLOSS Project Planets

IslandT: Sort list alphabetically with python

Planet Python - Thu, 2019-11-21 07:38

You will be given a vector of string(s). You must sort it alphabetically (case-sensitive!!) and then return the first value.

The returned value must be a string and have “***” between each of its letters.

You should not remove or add elements from/to the array.

Above is another problem in codewars, besides asking us to sort the array list and returning the first value in that list, we also need to insert stars within the characters.

def two_sort(array): array.sort() first_string = array[0] first_star_string = '' limit = len(first_string) for i in range(0, limit): if i == 0: first_star_string += first_string[i] else: first_star_string +='***'+first_string[i] return first_star_string

The python solution above is straight forward but needs further improvement if possible, do write down your own answer in the comment box below this post.

Categories: FLOSS Project Planets

Jonathan Dowland: 8-bit

Planet Debian - Thu, 2019-11-21 06:55

On Yesterday's Mary Anne Hobbs radio show she debuted a new track by Squarepusher, "Vortrack [Fracture Remix]", which you can now watch/listen to on YouTube:

This track really grabbed my attention. Later that day you you could buy it in a variety of formats and quality levels on Squarepusher's website.

One of the format/quality options was "8-bit Lossless WAV", which I thought was a joke, a poke in the eye of audiophiles. I was aware that he likely used some 8-bit instruments/equipment to write the tracks, but surely it was mixed in a more modern environment, and resampling down to 8-bit would result in something that sounded like mush.

But it seems the jokes on me; I bought the track and it's seemingly indistinguishable to the audio track on that YouTube video. And it really is 8-bit:

Input #0, wav, from 'Vortrack-001-Squarepusher-Vortrack (Fracture Remix).wav': Duration: 00:08:02.99, bitrate: 705 kb/s Stream #0:0: Audio: pcm_u8 ([1][0][0][0] / 0x0001), 44100 Hz, 2 channels, u8, 705 kb/s

It even — losslessly — compressed down to a bitrate lower than a typical MP3:

Input #0, flac, from 'Vortrack-001-Squarepusher-Vortrack (Fracture Remix).flac': Duration: 00:08:02.99, start: 0.000000, bitrate: 313 kb/s Stream #0:0: Audio: flac, 44100 Hz, stereo, s16 (8 bit)

Sorry, comments on my site seem to be broken at the moment. I'm hoping to fix them soon.

Categories: FLOSS Project Planets

Srijan Technologies: Get Personal With Customers Through Account-Based Marketing (ABM)

Planet Drupal - Thu, 2019-11-21 05:17

Gone are those days when traditional inbound marketing practices worked wonders. Today, the one-size-fits-all approach does not prove effective for companies trying to appeal to well-heeled clients and companies. 

Categories: FLOSS Project Planets

MD Systems blog: DrupalCon Amsterdam 2019 Recap

Planet Drupal - Thu, 2019-11-21 04:00
This year, Amsterdam, Netherlands celebrated its third time as a home city for the biggest European Drupal conference - DrupalCon. My (Miloš) overall experience was great and I am going to provide you with more insights in the next paragraphs below.
Categories: FLOSS Project Planets

Joachim Breitner: Faster Winter 4: Export lists

Planet Debian - Thu, 2019-11-21 02:52

(This is the forth optimization presented in the “faster winter” series, please see that post for background information.)

This is on a funny one: You can speed up your code by adding export lists to your modules!

Why is that so?

Without an export, the compiler has to assume that every top-level function can possibly called from the outside, even functions that you think of as “internal”. If you have a function that you do not export, like instr, step_work and step after my change, the compiler can see all the places the function is called. If the function is only called in one place, it may inline it (copy its definition into where it is called), and simplify the code around the edges. And even if it does not inline the function, it might learn something about how the functions are used, and optimize them based on that (e.g. based on Demand Analysis).

Improvement: Allocations: -22.59% Memory: +0.00% Time: -11.79% (Commit bbe8af7...6f2ba09)

Besides being a performance win, an explicit export list is also very helpful to those who want to read or edit your code: they can refactor with greater ease while maintaining the external interface of the module.

Categories: FLOSS Project Planets

Andre Roberge: Abolishing SyntaxError: invalid syntax ...

Planet Python - Thu, 2019-11-21 02:46
... and other cryptic messages.

Do you remember when you first started programming (possibly with Python) and encountered an error message that completely baffled you? For some reason, perhaps because you were required to complete a formal course or because you were naturally persistent, you didn't let such messages discourage you entirely and you persevered. And now, whenever you see such cryptic error messages, you can almost immediately decipher them and figure out what causes them and fix the problem.

Congratulations, you are part of an elite group! Even a large number of people who claim that they can program are almost certainly less capable than you are.

Given your good fortune, would you mind donating 5 to 10 minutes of your time to help countless beginners that are struggling in trying to understand Python error messages?  All you need to do is:

  1. Glance through of exceptions on this page and use your experience to find a case not covered. Note that this excludes SyntaxError cases, some of which are included here, but would require more of your time.
  2. Fire up your favourite Python REPL and write some simple code that generates an exception not already covered.  Perhaps, something like ValueError: could not convert string to float: 'a'
  3. Create a new issue with the error message as the title, including the code that generated the exception in the description of the issue together with a simple explanation (in a couple of sentences) of what the error message means.  Imagine that you are writing an explanation for the twelve year old child of your best friend who has expressed some interest in learning how to program.  This simple explanation is the most important part ... however, do not worry about getting it absolutely perfect as it will likely be improved upon based on feedback from future "real beginners".
  4. Go back to whatever you were doing before, knowing that the few minutes you have invested will cumulatively save many hours to future generation of programmers that encounter the exception you wrote about.
It should go without saying that contributions that require more time and effort that what is described above are also very welcome!  If you feel particularly ambitious, you can certainly improve the existing code that currently analyses cases of SyntaxError: invalid syntax, which currently handles only a few cases, and should be seen more as a prototype/proof-of-concept.Future plans for friendly-traceback
Friendly-traceback is being written so that it could be easily incorporated into editors or IDEs that are designed for beginners. I intend to ensure that it can be easily added to Python's IDLE, as well as Mu and Thonny. I hasten to add that Thonny already includes an excellent tool (its "Assistant") which provides amazing feedback to beginners in some cases. Thonny's assistant uses a complementary approach to that of Friendly-traceback and it is quite likely that a future version of Friendly-traceback will include and expand upon the type of analysis performed by Thonny's assistant to help beginners. However, for the moment, the current development of Friendly-traceback is focused on breadth of coverage (i.e. increasing the number of exceptions included), providing a single most-likely explanation for each exception, rather than looking at multiple possible causes for a given exception as is done by Thonny's Assistant.
Categories: FLOSS Project Planets

Kees Cook: experimenting with Clang CFI on upstream Linux

Planet Debian - Thu, 2019-11-21 00:09

While much of the work on kernel Control Flow Integrity (CFI) is focused on arm64 (since kernel CFI is available on Android), a significant portion is in the core kernel itself (and especially the build system). Recently I got a sane build and boot on x86 with everything enabled, and I’ve been picking through some of the remaining pieces. I figured now would be a good time to document everything I do to get a build working in case other people want to play with it and find stuff that needs fixing.

First, everything is based on Sami Tolvanen’s upstream port of Clang’s forward-edge CFI, which includes his Link Time Optimization (LTO) work, which CFI requires. This tree also includes his backward-edge CFI work on arm64 with Clang’s Shadow Call Stack (SCS).

On top of that, I’ve git a few x86-specific patches that get me far enough to boot a kernel without warnings pouring across the console. Along with that are general linker script cleanups, CFI cast fixes, and x86 crypto fixes, all in various states of getting upstreamed. The resulting tree is here.

On the compiler side, you need a very recent Clang and LLD (i.e. “Clang 10”, or what I do is build from the latest git). For example, here’s how to get started. First, checkout, configure, and build Clang (and include a RISC-V target just for fun):

# Check out latest LLVM mkdir -p $HOME/src cd $HOME/src git clone https://github.com/llvm/llvm-project.git mkdir llvm-build cd llvm-build # Configure cmake -DCMAKE_BUILD_TYPE=Release \ -DLLVM_ENABLE_PROJECTS='clang;lld' \ -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="RISCV" \ ../llvm-project/llvm # Build! make -j$(getconf _NPROCESSORS_ONLN) # Install cfi blacklist template (why is this missing from "make" above?) mkdir -p $(echo lib/clang/*)/share cp ../llvm-project/compiler-rt/lib/cfi/cfi_blacklist.txt lib/clang/*/share/cfi_blacklist.txt

Then checkout, configure, and build the CFI tree. (This assumes you’ve already got a checkout of Linus’s tree.)

# Check out my branch cd ../linux git remote add kees https://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git git fetch kees git checkout kees/kspp/cfi/x86 -b test/cfi # Configure (this uses "defconfig" but you could use "menuconfig"), but you must # include CC and LD in the make args or your .config won't know about Clang. make defconfig \ CC=$HOME/src/llvm-build/bin/clang LD=$HOME/src/llvm-build/bin/ld.lld # Enable LTO and CFI. scripts/config \ -e CONFIG_LTO \ -e CONFIG_THINLTO \ -d CONFIG_LTO_NONE \ -e CONFIG_LTO_CLANG \ -e CONFIG_CFI_CLANG \ -e CONFIG_CFI_PERMISSIVE \ -e CONFIG_CFI_CLANG_SHADOW # Enable LKDTM if you want runtime fault testing: scripts/config -e CONFIG_LKDTM # Build! make -j$(getconf _NPROCESSORS_ONLN) \ CC=$HOME/src/llvm-build/bin/clang LD=$HOME/src/llvm-build/bin/ld.lld

Do not be alarmed by various warnings, such as:

ld.lld: warning: cannot find entry symbol _start; defaulting to 0x1000 llvm-ar: error: unable to load 'arch/x86/kernel/head_64.o': file too small to be an archive llvm-ar: error: unable to load 'arch/x86/kernel/head64.o': file too small to be an archive llvm-ar: error: unable to load 'arch/x86/kernel/ebda.o': file too small to be an archive llvm-ar: error: unable to load 'arch/x86/kernel/platform-quirks.o': file too small to be an archive WARNING: EXPORT symbol "page_offset_base" [vmlinux] version generation failed, symbol will not be versioned. WARNING: EXPORT symbol "vmalloc_base" [vmlinux] version generation failed, symbol will not be versioned. WARNING: EXPORT symbol "vmemmap_base" [vmlinux] version generation failed, symbol will not be versioned. WARNING: "__memcat_p" [vmlinux] is a static (unknown) no symbols

Adjust your .config as you want (but, again, make sure the CC and LD args are pointed at Clang and LLD respectively). This should(!) result in a happy bootable x86 CFI-enabled kernel. If you want to see what a CFI failure looks like, you can poke LKDTM:

# Log into the booted system as root, then: cat <(echo CFI_FORWARD_PROTO) >/sys/kernel/debug/provoke-crash/DIRECT dmesg

Here’s the CFI splat I see on the console:

[ 16.288372] lkdtm: Performing direct entry CFI_FORWARD_PROTO [ 16.290563] lkdtm: Calling matched prototype ... [ 16.292367] lkdtm: Calling mismatched prototype ... [ 16.293696] ------------[ cut here ]------------ [ 16.294581] CFI failure (target: lkdtm_increment_int$53641d38e2dc4a151b75cbe816cbb86b.cfi_jt+0x0/0x10): [ 16.296288] WARNING: CPU: 3 PID: 2612 at kernel/cfi.c:29 __cfi_check_fail+0x38/0x40 ... [ 16.346873] ---[ end trace 386b3874d294d2f7 ]--- [ 16.347669] lkdtm: Fail: survived mismatched prototype function call!

The claim of “Fail: survived …” is due to CONFIG_CFI_PERMISSIVE=y. This allows the kernel to warn but continue with the bad call anyway. This is handy for debugging. In a production kernel that would be removed and the offending kernel thread would be killed. If you run this again with the config disabled, there will be no continuation from LKDTM. :)

Enjoy! And if you can figure out before me why there is still CFI instrumentation in the KPTI entry handler, please let me know and help us fix it. ;)

© 2019, Kees Cook. This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 License.

Categories: FLOSS Project Planets

Wingware Blog: Navigating Python Code with Wing Pro 7 (part 2 of 3)

Planet Python - Wed, 2019-11-20 20:00

Last week we looked at goto-definition, find uses, and project-wide search as tools for navigating Python code in Wing 7. This time, we'll take a look at the code indices that Wing provides.

Code Index Menus

A quick way to navigate code in the current Python file is to use the source index menus shown at the top of the editor:

Depending on the location of the caret in the editor, Wing may show multiple menus, as in the above example: One for the contents of the top level of the file, one for the contents of the current top-level scope, and additional menus for each sub-scope. Clicking on any of these provides an index and selecting an item jumps to that place in the source code.

Source Browser

In Wing Pro only, the Source Browser in the Tools menu provides another way to view an index of your source code, either for the current module, all project modules, or all classes:

The scope being browsed and the types of symbols shown may be selected by clicking on the menus at the top of the tool. Double-clicking on items displays them in the editor.

Browsing all project modules or classes assume that you have used Add Existing Directory in the Project menu to add your source code to your project. Typically the project should contain the code you are actively working on. Packages that your code uses can be left out of the project, unless you anticipate often wanting to open or search files in them. Wing will still be able to find them through the Python Path configured by Python or in Wing's Project Properties.

That's it for now! We'll be back next week to conclude this Wing Tips mini-series on navigating Python code with Wing.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Categories: FLOSS Project Planets

Tandem's Drupal Blog: Preparing for Drupal 9 with Lando + PHPStan

Planet Drupal - Wed, 2019-11-20 19:00
November 21, 2019 Drupal 9 is right around the corner. It is very easy to get your sites ready with Lando + PHPStan. Overview Drupal 9 will be released on June 3, 2020. It is crazy to think that because it feels like Drupal 8 just came out. A lot has changed in the Drupal universe since the release of Drupal 8. Mainly the framework on which ...
Categories: FLOSS Project Planets

NumFOCUS: NumFOCUS Summit 2019

Planet Python - Wed, 2019-11-20 18:24

The post NumFOCUS Summit 2019 appeared first on NumFOCUS.

Categories: FLOSS Project Planets