iOS 27, sesle iPhone / iPad kontrolünü çok daha doğal hale getirecek [Video]

yazar
iPhone

iPhoneApple tarafından yapılan resmi açıklamaya göre sesli komutlarla iPhone ve iPad’i kontrol etme süreci Apple Intelligence sayesinde çok daha doğal hale geliyor. Apple’ın, “Apple Intelligence sayesinde Sesle Denetim, çeşitli fiziksel engellere sahip kullanıcıların iPhone ve iPad’i tamamen sesle kontrol etmelerine yardımcı olmak için doğal dilden yararlanarak şimdi her zamankinden daha pratik hale geliyor. Yeni esnek giriş olanağıyla kullanıcılar, etiketleri veya numaraları ezberlemek yerine ekrandaki düğmeleri ve kontrolleri doğal dil kullanarak açıklayabiliyor. “Gördüğünüzü söyleyin” seçeneği, Apple Harita veya Dosyalar gibi görsel düzenlere sahip olanlar dahil tüm uygulamalarda “en iyi restoranlarla ilgili kılavuza dokun” veya “mor klasöre dokun” gibi pratik bir dil kullanarak kolayca gezinme imkanı sunuyor. Bu özellik, öğelerin erişilebilirlik için doğru şekilde etiketlenmediği durumlarda da kullanıcıların engelleri aşmalarını sağlıyor.” açıklamasını yaptığı, resmi oalrak aşağıdaki videoda gözler önüne serilen sistem, maalesef ilk aşamada Türkçe / Türkiye desteğine sahip olmayacak. “Apple Intelligence ile desteklenen Sesle Denetim; ABD, Kanada, Birleşik Krallık ve Avustralya’da […]

iOS 27, sesle iPhone / iPad kontrolünü çok daha doğal hale getirecek [Video] yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.

Instruction: how to create a website (HTML file, webpage, or HTML document)

yazar

To create an HTML page and view it, we will use your pre-installed programs, such as a text editor and a browser.

  1. First step: you need to create a file “index.html” with the “.html” extension. To do this, use this instruction to enable file extensions:

Create a file: index.html

  1. The second step is to place this code in an index.html file. To do this, open your index.html file in a text editor or in a code editor, copy this code, paste it into the editor, and save the changes or save file (or save as “index.html”).

code:

<!DOCTYPE html>
<html>
<head>
<title>This is a title</title>
</head>
<body>
<p>Hello world!</p>
</body>
</html>

  1. Done. Open your index.html file in a browser, such as Chrome, Firefox, Edge, or Safari, to see the result.

Sources:

Forgelab PDF API Review: Affordable REST API for PDF Merge, Split, and Compress

yazar

PDF processing looks trivial until you ship it. Merging two files, splitting a report into per-chapter documents, compressing a 40 MB scan so it clears an email size limit — each one is a solved problem inside some library, and each one becomes your problem the moment it runs in production. Forgelab shipped a PDF API in May 2026 that bets you would rather not own that problem. It starts at $5 a month. We worked through its endpoint design and pricing to figure out who that number actually serves.

What Forgelab’s PDF API actually does

Forgelab’s PDF API exposes four operations behind a plain REST interface:

  • Merge — combine multiple PDFs into a single document.
  • Split — break one PDF into several separate files.
  • Compress — reduce file size for storage or email limits.
  • PDF-to-image — render PDF pages as image files.

You send a request, you get a processed file back. There is no SDK to install, no native binary to compile against, no headless browser to keep alive. If you have ever shipped a feature that leaned on Ghostscript or a Chromium render farm, that absence is the entire pitch.

The $5 entry price is the other half of it. PDF work is rarely a product’s core feature — it is the invoice export, the report download, the combine-these-uploads button. Spending an engineering week on something that peripheral is hard to justify, and so is an enterprise contract. A few dollars a month for a working endpoint changes that math.

What the launch material leaves out matters just as much: there is no published rate limit, no uptime commitment, and no detailed breakdown of how higher-volume tiers are priced. Read the four operations as confirmed and the operational guarantees as still unknown — we come back to that below.

The buy-versus-build math for PDF processing

Three paths exist for PDF processing, and the real cost of each is mostly hidden.

Self-hosting a library looks free. pdf-lib, Apache PDFBox, qpdf, Ghostscript, and mupdf all merge, split, and compress without a license fee. The cost shows up later. Ghostscript carries a long history of security advisories, malformed PDFs exhaust memory in ways that are hard to reproduce, and compression quality depends on flags you will spend a day tuning. Free libraries are not free — they are deferred maintenance, and you are the one who pays it.

Adobe PDF Services API is the enterprise answer. It is broad, well-documented, and dependable. It is also priced and scoped for organizations running document pipelines, not for a solo developer adding a download button. For a small SaaS, you are buying surface area you will never touch.

A low-cost API sits in the gap between those two:

None of this makes Forgelab automatically the right pick. It makes it a genuine third option where, for small teams, there were only two awkward ones before.

Forgelab’s PDF API is new. The launch announcement does not publish an uptime SLA, concrete rate limits, or a retention policy for uploaded files. Before you route customer documents through it, get answers to two questions: how long are uploaded files stored, and what is your fallback if the endpoint returns errors for an hour? Treat it as a dependency you can swap — not one you build your product on top of.

Where a hosted PDF API fits — and where it doesn’t

This kind of service earns its place when PDF handling is a feature, not the product. Invoice and receipt generation, letting users combine uploaded documents, compressing files before you store them, turning a PDF report into preview thumbnails — all of that is a clean fit. The work is occasional, the volume is moderate, and nobody on the team wants to be the person who owns the PDF library.

It fits poorly in three cases. If PDFs are your product — a document editor, a contract platform — you want that pipeline in-house, where you control quality and latency. If you handle regulated or sensitive documents, sending them to a third-party processor is a compliance conversation, not a coding decision. And if you process at high volume, per-operation economics can flip against you; check Forgelab’s upper tiers against your real numbers before you commit.

The integration itself is light: an HTTP client, a multipart upload or file reference, error handling, and a retry when a render fails. That is glue code — the kind of task an AI-assisted editor clears in minutes.

Whatever PDF API you choose, wrap it behind your own small interface — a pdfService.merge() function rather than raw HTTP calls scattered across your codebase. If Forgelab raises prices, adds latency, or you outgrow it, swapping providers becomes a one-file change instead of a refactor.

Forgelab’s PDF API will not be the deepest PDF tool you can buy, and at $5 a month it does not need to be. It needs to be cheaper than your time and simpler than Adobe. For a small team shipping a document feature, it clears both bars — provided you treat the missing SLA and retention details as open questions, not afterthoughts.

Originally published at pickuma.com. Subscribe to the RSS or follow @pickuma.bsky.social for new reviews.

UseState – Exercises

yazar

*Toggle Button * 

import { useState } from "react";

function Toggle(){

   const [bulb,setBulb] = useState("https://www.w3schools.com/js/pic_bulboff.gif")
//    const [flag,setFlag] = useState(false);





   function toggle(){
    if (bulb === "https://www.w3schools.com/js/pic_bulboff.gif"){
        setBulb("https://www.w3schools.com/js/pic_bulbon.gif")
        // setFlag(true);
    }
    else{
        setBulb("https://www.w3schools.com/js/pic_bulboff.gif")
        // setFlag(false);
    }
   }



    return(
        <>
        <img src= {bulb}></img>
        <button onClick = {toggle}>{bulb==="https://www.w3schools.com/js/pic_bulboff.gif"?"ON":"OFF"}</button>
        </>

    )


}

export default Toggle

output:

Input Field Value 

import { useState } from "react";

function Input(){

    const[name,setName] = useState('')




    return(
    <>
      <input value={name} type="text" onChange={(e)=>setName(e.target.value)}></input>
        <p>Hi! Welcome {name}</p>
        </>

    )

}

export default Input

Output:

Show/Hide Text 

function Show(){

    const[text,setText] = useState("");
    const[show,setShow] = useState(false);



    function showContent(){
        if(show===false){
             setShow(true);
        }
        else{
            setShow(false);
        }

    }

    return(
        <>
        <input type="password" onChange={(e)=>setText(e.target.value)}></input>
        <button onClick={showContent}>{show===false ?"Show":"Hide"}</button>
        {show && <p>{text}</p>}
        </>

    )
}

export default Show

Output:

Character Counter 

import { useState } from "react";

function Character (){

const [count,setCount] = useState(0);

    return(
        <>
        <input type="text" onChange={(e)=>setCount(e.target.value.length)}></input>
        <p>Count :{count} </p>
        </>

    )
}

export default Character

Output:

Form with Multiple Input 

import { useState } from "react";


function Multiple(){

    const[name,setName]= useState('');
    const[email,setEmail]= useState('');
    const[number,setNumber]= useState('');
    const[city,setCity]= useState('');
    const[password,setPassword]= useState('');



    return(
        <>
        <input type="text" onChange={(e)=>setName(e.target.value)}></input>
        <input type="email" onChange={(e)=>setEmail(e.target.value)}></input>
        <input type="text" onChange={(e)=>setNumber(e.target.value)}></input>
        <input type="text" onChange={(e)=>setCity(e.target.value)}></input>
        <input type="password" onChange={(e)=>setPassword(e.target.value)}></input>
        </>
    )
}

export default Multiple

CheckBox Selection List 

import { useState } from "react";

function Selection(){

    const [value,setValue] = useState([]);
    const [checked,setChecked] = useState(false);

   function addValue(e) {

        const checked = e.target.checked;
        const item = e.target.value;

        if (checked) {
            setValue([...value, item]);
        } else {
            setValue(value.filter((val) => val !== item));
        }
    }

    return(
        <>
        <input value="React" type="checkbox" onChange={addValue}></input>
        <label>React</label>
        <input value="Node" type="checkbox" onChange={addValue}></input>
        <label>Node</label>
        <input value="Java" type="checkbox" onChange={addValue}></input>
        <label>Java</label>
        <input value="SQL" type="checkbox" onChange={addValue}></input>
        <label>SQL</label>

        <ul>
                {value.map((val, index) => (
                    <li key={index}>{val}</li>
                ))}
            </ul>
        </>
    )
}

export default Selection

Output:

Dependent Dropdown 

import { useState } from "react";

function Dependent() {

    const states = {
        india: ["tamilnadu", "kerala"],
        usa: ["arizona", "newyork"]
    };

    const cities = {
        tamilnadu: ["chennai", "trichy"],
        kerala: ["trivandrum", "kochi"],
        arizona: ["phoenix"],
        newyork: ["washington"]
    };

    const [country, setCountry] = useState("");
    const [state, setState] = useState("");
    const [city, setCity] = useState("");

    return (
        <>

            <select value={country}
         onChange={(e) => {
        setCountry(e.target.value);
        setState("");
        setCity("");
        }}
        >   

                <option value="">Select Country</option>

                <option value="india">India</option>

                <option value="usa">USA</option>

            </select>


            <select value={state} onChange={(e) => {
                setState(e.target.value);
                setCity("");

            }

            }>

                <option value="">Select State</option>

                {
                    country &&
                    states[country].map((val, index) => (
                        <option key={index} value={val}>
                            {val}
                        </option>
                    ))
                }

            </select>


            <select value={city} onChange={(e) => setCity(e.target.value)}>

                <option value="">Select City</option>

                {
                   country && state &&
                    cities[state].map((val, index) => (
                        <option key={index} value={val}>
                            {val}
                        </option>
                    ))
                }

            </select>


        </>
    );
}

export default Dependent;

Output:

The Pope, Anthropic, and the Weight of Rerum Novarum

yazar

On May 25, an American pope will stand in the Vatican’s Synod Hall and present the first papal encyclical on artificial intelligence. Alongside him: Christopher Olah, co-founder of Anthropic and one of the field’s leading interpretability researchers. The document is called Magnifica Humanitas, or “Magnificent Humanity.” Pope Leo XIV signed it on May 15, 135 years to the day after his namesake, Leo XIII, signed Rerum Novarum, the encyclical that defined Catholic social teaching on labor and capitalism as the Industrial Revolution reshaped the world.

That date was not a coincidence. It was a claim.

The Church is saying, explicitly, that AI is the industrial revolution of our moment. The same questions about human dignity, labor, and the limits of capital that Leo XIII addressed in 1891 are back. The framing is grand, but it’s also serious: Rerum Novarum became the foundation of modern Catholic social thought on workers’ rights. The current pope has already been citing it in speeches. If this encyclical lands with similar weight, it will be the most significant moral framework for AI published by any institution outside a technology lab itself.

What makes the moment stranger: Anthropic is currently suing the Trump administration, which in February ordered all U.S. agencies to stop using the company’s technology. The White House reportedly imposed those penalties because Anthropic refused to grant the military unrestricted use of its AI. Having Anthropic’s co-founder on the Vatican stage presenting a document on AI and human dignity is not a neutral act. PBS framed it bluntly: Olah’s presence “suggests that the U.S. pope’s position on AI will become a new flashpoint with the Trump administration.”

I find this genuinely hard to parse, and that’s why I keep thinking about it.

The obvious read is that the Vatican chose a side, the safety-focused AI company over the military-access-first posture of the current U.S. government. And it did so not with a press release or a policy brief, but with the most solemn form of papal teaching available. That’s a lot of institutional weight to throw behind one company’s positioning.

The less cynical read is that Olah, specifically, makes sense here. He’s not Dario Amodei. He’s the person most associated with Anthropic’s mechanistic interpretability work: the attempt to actually understand what’s happening inside these models. If the Vatican wanted an AI researcher who could speak honestly about uncertainty, opacity, and the genuine unknowability of these systems, Olah is a reasonable choice. His concern about AI isn’t performative. Whether his presence gets read that way is a separate question.

The encyclical itself hasn’t been published yet. It drops in four days. What it actually argues will matter more than the staging. But the staging already tells you something. This is not the Vatican issuing a cautious statement through the Pontifical Academy of Sciences. The pope will be in the room, breaking with the usual protocol of delegating presentations to officials. Two senior cardinals are presenting alongside theologians from Durham and Santa Clara. The ceremony is in the main Vatican auditorium.

The Church has done this before with transformative technologies. It was usually slow, often wrong, and occasionally right in ways that outlasted the politics of the moment. Whether Magnifica Humanitas joins that tradition or collapses into a well-intentioned document nobody reads past the headlines, that’s the question. But as a signal that AI ethics has moved from conference panels to the oldest continuous moral institution in the Western world, this week is hard to dismiss.

The last time a pope addressed a technology by invoking Leo XIII, the resulting framework shaped labor law across multiple continents. That’s a high bar. Four days to see if the document itself comes anywhere close.